Valid HTML 4.0! Valid CSS!
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.84",
%%%     date            = "30 September 2024",
%%%     time            = "08:58:08 MDT",
%%%     filename        = "tosem.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             = "https://www.math.utah.edu/~beebe",
%%%     checksum        = "14221 40703 204757 1991980",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "bibliography; BibTeX; ACM Transactions on
%%%                        Software Engineering and Methodology",
%%%     license         = "public domain",
%%%     supported       = "no",
%%%     docstring       = "This is a COMPLETE BibTeX bibliography for
%%%                        the journal ACM Transactions on Software
%%%                        Engineering and Methodology (CODEN ATSMER,
%%%                        ISSN 1049-331X (print), 1557-7392
%%%                        (electronic)), for 1992--date.
%%%
%%%                        Publication began with volume 1, number 1, in
%%%                        January 1992.  The journal appears quarterly.
%%%
%%%                        The journal has a joint World-Wide Web site
%%%                        at:
%%%
%%%                            http://www.acm.org/pubs/tosem
%%%
%%%                        Tables-of-contents of all issues are
%%%                        available at:
%%%
%%%                            http://www.acm.org/pubs/contents/journals/tosem/
%%%                            https://dl.acm.org/loi/tosem
%%%
%%%                        Qualified subscribers can retrieve the full
%%%                        text of recent articles in PDF form.
%%%
%%%                        At version 1.84, the COMPLETE journal
%%%                        coverage looked like this:
%%%
%%%                             1992 (  15)    2003 (  14)    2014 (  47)
%%%                             1993 (  13)    2004 (  10)    2015 (  24)
%%%                             1994 (  12)    2005 (  15)    2016 (  17)
%%%                             1995 (  12)    2006 (  12)    2017 (  13)
%%%                             1996 (  14)    2007 (  19)    2018 (  25)
%%%                             1997 (  13)    2008 (  23)    2019 (  28)
%%%                             1998 (  14)    2009 (  14)    2020 (  33)
%%%                             1999 (  13)    2010 (  14)    2021 (  57)
%%%                             2000 (  14)    2011 (  18)    2022 (  86)
%%%                             2001 (  11)    2012 (  19)    2023 ( 161)
%%%                             2002 (  15)    2013 (  38)    2024 ( 195)
%%%
%%%                             Article:       1028
%%%
%%%                             Total entries: 1028
%%%
%%%                        The initial draft of this bibliography was
%%%                        derived from data at the ACM Web site.
%%%
%%%                        ACM copyrights explicitly permit abstracting
%%%                        with credit, so article abstracts, keywords,
%%%                        and subject classifications have been
%%%                        included in this bibliography wherever
%%%                        available.
%%%
%%%                        The bibsource keys in the bibliography
%%%                        entries below indicate the data sources.
%%%
%%%                        URL keys in the bibliography point to
%%%                        World Wide Web locations of additional
%%%                        information about the entry.
%%%
%%%                        Spelling has been verified with the UNIX
%%%                        spell and GNU ispell programs using the
%%%                        exception dictionary stored in the
%%%                        companion file with extension .sok.
%%%
%%%                        BibTeX citation tags are uniformly chosen
%%%                        as name:year:abbrev, where name is the
%%%                        family name of the first author or editor,
%%%                        year is a 4-digit number, and abbrev is a
%%%                        3-letter condensation of important title
%%%                        words. Citation tags were automatically
%%%                        generated by software developed for the
%%%                        BibNet Project.
%%%
%%%                        In this bibliography, entries are sorted in
%%%                        publication order, using ``bibsort -byvolume.''
%%%
%%%                        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{"\input bibnames.sty" #
    "\ifx \undefined \emph         \def \emph      #1{{{\em #1\/}}}     \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|https://www.math.utah.edu/~beebe/|"}

%%% ====================================================================
%%% Journal abbreviations:
@String{j-TOSEM                 = "ACM Transactions on Software Engineering and
                                   Methodology"}

%%% ====================================================================
%%% Bibliography entries:
@Article{Offutt:1992:IST,
  author =       "A. Jefferson Offutt",
  title =        "Investigations of the software testing coupling
                 effect",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "1",
  pages =        "5--20",
  month =        jan,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-1/p5-offutt/p5-offutt.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-1/p5-offutt/",
  abstract =     "Fault-based testing strategies test software by
                 focusing on specific, common types of faults. The {\em
                 coupling effect\/} hypothesizes that test data sets
                 that detect simple types of faults are sensitive enough
                 to detect more complex types of faults. This paper
                 describes empirical investigations into the coupling
                 effect over a specific class of software faults. All of
                 the results from this investigation support the
                 validity of the coupling effect. The major conclusion
                 from this investigation is the fact that by explicitly
                 testing for simple faults, we are also implicitly
                 testing for more complicated faults, giving us
                 confidence that fault-based testing is an effective way
                 to test software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "fault-based testing; mutation; software testing; unit
                 testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Reliability}",
}

@Article{Olender:1992:ISA,
  author =       "Kurt M. Olender and Leon J. Osterweil",
  title =        "Interprocedural static analysis of sequencing
                 constraints",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "1",
  pages =        "21--52",
  month =        jan,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-1/p21-olender/p21-olender.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-1/p21-olender/",
  abstract =     "This paper describes a system that automatically
                 performs static interprocedural sequencing analysis
                 from programmable constraint specifications. We
                 describe the algorithms used for interprocedural
                 analysis, relate the problems arising from the analysis
                 of real-world programs, and show how these difficulties
                 were overcome. Finally, we sketch the architecture of
                 our prototype analysis system (called Cesar) and
                 describe our experiences to date with its use, citing
                 performance and error detection characteristics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Languages; Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "error detection; interprocedural data flow analysis;
                 sequencing constraints",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Validation}; Software ---
                 Software Engineering --- Testing and Debugging (D.2.5):
                 {\bf Debugging aids}; Software --- Software Engineering
                 --- Requirements/Specifications (D.2.1): {\bf
                 Methodologies (e.g., object-oriented, structured)};
                 Software --- Programming Techniques --- Sequential
                 Programming (D.1.4); Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf
                 Computer-aided software engineering (CASE)}; Software
                 --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Reliability}; Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Languages}",
}

@Article{Basili:1992:RAC,
  author =       "Victor R. Basili and Gianluigi Caldiera and Giovanni
                 Cantone",
  title =        "A reference architecture for the component factory",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "1",
  pages =        "53--80",
  month =        jan,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-1/p53-basili/p53-basili.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-1/p53-basili/",
  abstract =     "Software reuse can be achieved through an organization
                 that focuses on utilization of life cycle products from
                 previous developments. The component factory is both an
                 example of the more general concepts of experience and
                 domain factory and an organizational unit worth being
                 considered independently. The critical features of such
                 an organization are flexibility and continuous
                 improvement. In order to achieve these features we can
                 represent the architecture of the factory at different
                 levels of abstraction and define a reference
                 architecture from which specific architectures can be
                 derived by instantiation. A reference architecture is
                 an implementation and organization independent
                 representation of the component factory and its
                 environment. The paper outlines this reference
                 architecture, discusses the instantiation process, and
                 presents some examples of specific architectures by
                 comparing them in the framework of the reference
                 model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Economics; Management; Measurement;
                 Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "component factory; experience factory; reference
                 architecture; reusability",
  subject =      "Software --- Software Engineering --- Management
                 (D.2.9); Software --- Software Engineering ---
                 Miscellaneous (D.2.m): {\bf Reusable software**};
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3):
                 {\bf Software development}; Software --- Software
                 Engineering --- Requirements/Specifications (D.2.1):
                 {\bf Methodologies (e.g., object-oriented,
                 structured)}; Software --- Software Engineering ---
                 Design Tools and Techniques (D.2.2): {\bf Software
                 libraries}",
}

@Article{Trammell:1992:APC,
  author =       "Carmen J. Trammell and Leon H. Binder and Cathrine E.
                 Snyder",
  title =        "The automated production control documentation system:
                 a case study in cleanroom software engineering",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "1",
  pages =        "81--94",
  month =        jan,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-1/p81-trammell/p81-trammell.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-1/p81-trammell/",
  abstract =     "A prototype software system was developed for the U.S.
                 Naval Underwater Systems Center(NUSC) as a
                 demonstration of the Cleanroom Software Engineering
                 methodology. The Cleanroom method is a team approach to
                 the incremental development of software under
                 statistical quality control. Cleanroom's formal methods
                 of Box Structure specification and design, functional
                 verification, and statistical testing were used by a
                 four-person team to develop the Automated Production
                 Control Documentation(APCODOC) system, a relational
                 database application. As is typical in Cleanroom
                 developments, correctness of design and code were
                 ensured through team reviews. Eighteen errors were
                 found during functional verification of the design, and
                 nineteen errors were found during walkthrough of the
                 1820 lines of FOXBASE code. The software was not
                 executed by developers prior to independent testing
                 (i.e., there was no debugging). There were no errors in
                 compilation, no failures during statistical
                 certification testing, and the software was certified
                 at the target levels of reliability and confidence.
                 Team members attribute the ultimate error-free
                 compilation and failure-free execution of the software
                 to the rigor of the methodology and the intellectual
                 control afforded by the team approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management; Performance; Reliability;
                 Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "box structures; cleanroom software engineering;
                 statistical quality control; statistical testing",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Software/Program Verification
                 (D.2.4): {\bf Correctness proofs}; Software ---
                 Software Engineering --- Management (D.2.9): {\bf
                 Programming teams}; Computing Milieux --- Management of
                 Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software development};
                 Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Reliability}",
}

@Article{Ballance:1992:PLB,
  author =       "Robert A. Ballance and Susan L. Graham and Michael L.
                 Van de Vanter",
  title =        "The {Pan} language-based editing system",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "1",
  pages =        "95--127",
  month =        jan,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-1/p95-ballance/p95-ballance.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-1/p95-ballance/",
  abstract =     "Powerful editing systems for developing complex
                 software documents are difficult to engineer. Besides
                 requiring efficient incremental algorithms and complex
                 data structures, such editors must accommodate flexible
                 editing styles, provide a consistent, coherent, and
                 powerful user interface, support individual variations
                 and projectwide configurations, maintain a sharable
                 database of information concerning the documents being
                 edited, and integrate smoothly with the other tools in
                 the environment. {\em Pan\/} is a language-based
                 editing and browsing system that exhibits these
                 characteristics. This paper surveys the design and
                 engineering of {\em Pan}, paying particular attention
                 to a number of issues that pervade the system:
                 incremental checking and analysis, information
                 retention in the presence of change, tolerance for
                 errors and anomalies, and extension facilities.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Documentation; Human Factors; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "coherent user interfaces; colander; contextual
                 constraint; extension facilities; grammatical
                 abstraction; interactive programming environment;
                 Ladle; logic programming; logical constraint grammar;
                 Pan; reason maintenance; syntax-recognizing editor;
                 tolerance for errors and anomalies",
  subject =      "Software --- Software Engineering --- Coding Tools and
                 Techniques (D.2.3): {\bf Program editors}; Software ---
                 Software Engineering --- Programming Environments
                 (D.2.6); Software --- Software Engineering --- Design
                 Tools and Techniques (D.2.2): {\bf User interfaces};
                 Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7)",
}

@Article{Engels:1992:BIS,
  author =       "G. Engels and C. Lewerentz and M. Nagl and W.
                 Sch{\"a}fer and A. Sch{\"u}rr",
  title =        "Building integrated software development environments.
                 {Part} {I} tool specification",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "2",
  pages =        "135--167",
  month =        apr,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-2/p135-engels/p135-engels.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-2/p135-engels/",
  abstract =     "The conceptual modeling approach of the IPSEN
                 (Integrated Project Support Environment) project for
                 building highly integrated environments is based on
                 using attributed graphs to model and implement
                 arbitrary object structures, in particular all kinds of
                 software documents and their relationships. A language
                 based on graph grammars, called PROGRESS (PROgrammed
                 Graph REwriting SyStems), and a suitable method for the
                 application of this language, called graph grammar
                 engineering, have been developed over the last ten
                 years. This language and method are being extensively
                 used for specifying the complex graph structures of
                 internal document representations as well as for
                 specifying the functionality of all tools (editors,
                 browsers, analyzers, debuggers) working on these
                 internal representations. This paper explains the
                 language and the method for applying the language based
                 on a pragmatic nontrivial example of a software
                 production process and its corresponding documents. In
                 particular, it is shown why and how a graph
                 grammar-based strongly typed language is perfectly
                 suitable to formally specify highly integrated software
                 tools. In addition, it is shown that the implementation
                 of these tools (i.e., an environment composed of these
                 tools) is systematically being derived from the formal
                 specifications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "attribute grammars; attributed graphs; environment
                 generators; graph grammars",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Software Engineering ---
                 Programming Environments (D.2.6); Software --- Software
                 Engineering --- Design** (D.2.10); Information Systems
                 --- Database Management --- Languages (H.2.3); Software
                 --- Programming Languages --- Language Classifications
                 (D.3.2)",
}

@Article{Kiper:1992:STR,
  author =       "James D. Kiper",
  title =        "Structural testing of rule-based expert systems",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "2",
  pages =        "168--187",
  month =        apr,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-2/p168-kiper/p168-kiper.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-2/p168-kiper/",
  abstract =     "Testing of rule-based expert systems has become a high
                 priority for many organizations as the use of such
                 systems proliferates. Traditional software testing
                 techniques apply to some components of rule-based
                 systems, e.g., the inference engine. However, to
                 structurally test the rule base component requires new
                 techniques or adaptations of existing ones. This paper
                 describes one such adaptation: an extension of data
                 flow path selection in which a graphical representation
                 of a rule base is defined and evaluated. This graphical
                 form, called a logical path graph, captures logical
                 paths through a rule base. These logical paths create
                 precisely the abstractions needed in the testing
                 process. An algorithm for the construction of logical
                 path graphs are analyzed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Experimentation; Measurement;
                 Performance; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "basis path testing; data flow path selection; expert
                 systems; rule bases; structured testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Computing Methodologies ---
                 Artificial Intelligence --- Programming Languages and
                 Software (I.2.5): {\bf Expert system tools and
                 techniques}",
}

@Article{Schneider:1992:ESF,
  author =       "G. Michael Schneider and Johnny Martin and W. T.
                 Tsai",
  title =        "An experimental study of fault detection in user
                 requirements documents",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "2",
  pages =        "188--204",
  month =        apr,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-2/p188-schneider/p188-schneider.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-2/p188-schneider/",
  abstract =     "This paper describes a software engineering experiment
                 designed to confirm results from an earlier project
                 which measured fault detection rates in {\em user
                 requirements documents\/} (URD). The experiment
                 described in this paper involves the creation of a
                 standardized URD with a known number of injected faults
                 of specific type. Nine independent inspection teams
                 were given this URD with instructions to locate as many
                 faults as possible using the N-fold requirements
                 inspection technique developed by the authors. Results
                 obtained from this experiment confirm earlier
                 conclusions about the low rate of fault detection in
                 requirements documents using formal inspections and the
                 advantages to be gained using the N-fold inspection
                 method. The experiment also provides new results
                 concerning variability in inspection team performance
                 and the relative difficulty of locating different
                 classes of URD faults.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Experimentation; Management; Performance;
                 Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "fault detection; inspections; user requirements",
  subject =      "Software --- Software Engineering --- Management
                 (D.2.9): {\bf Programming teams}; Computing Milieux ---
                 Management of Computing and Information Systems ---
                 Software Management (K.6.3): {\bf Software
                 development}; Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Tools};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}",
}

@Article{Ostertag:1992:CSR,
  author =       "Eduardo Ostertag and James Hendler and Rub{\'e}n
                 Prieto D{\'\i}az and Christine Braun",
  title =        "Computing similarity in a reuse library system: an
                 {AI-based} approach",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "3",
  pages =        "205--228",
  month =        jul,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-3/p205-ostertag/p205-ostertag.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-3/p205-ostertag/",
  abstract =     "This paper presents an AI based library system for
                 software reuse, called AIRS, that allows a developer to
                 browse a software library in search of components that
                 best meet some stated requirement. A {\em component\/}
                 is described by a set of ({\em feature, term\/}) pairs.
                 A feature represents a classification criterion, and is
                 defined by a set of related terms. The system allows to
                 represent {\em packages\/} (logical units that group a
                 set of components) which are also described in terms of
                 features. Candidate reuse components and packages are
                 selected from the library based on the degree of
                 similarity between their descriptions and a given
                 target description. Similarity is quantified by a
                 nonnegative magnitude ({\em distance\/}) proportional
                 to the effort required to obtain the target given a
                 candidate. Distances are computed by {\em comparator\/}
                 functions based on the {\em subsumption, closeness},
                 and {\em package\/} relations. We present a
                 formalization of the concepts on which the AIRS system
                 is based. The functionality of a prototype
                 implementation of the AIRS system is illustrated by
                 application to two different software libraries: a set
                 of Ada packages for data structure manipulation, and a
                 set of C components for use in Command, Control, and
                 Information Systems. Finally, we discuss some of the
                 ideas we are currently exploring to automate the
                 construction of AIRS classification libraries.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "facet classification; similarity-based retrieval",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Software libraries}; Software
                 --- Software Engineering --- Metrics (D.2.8): {\bf
                 Complexity measures}; Information Systems ---
                 Information Storage and Retrieval --- Information
                 Search and Retrieval (H.3.3): {\bf Retrieval models};
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3):
                 {\bf Software selection}; Software --- Software
                 Engineering --- Miscellaneous (D.2.m): {\bf Reusable
                 software**}",
}

@Article{Sullivan:1992:REI,
  author =       "Kevin J. Sullivan and David Notkin",
  title =        "Reconciling environment integration and software
                 evolution",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "3",
  pages =        "229--268",
  month =        jul,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-3/p229-sullivan/p229-sullivan.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-3/p229-sullivan/",
  abstract =     "Common software design approaches complicate both tool
                 integration and software evolution when applied in the
                 development of integrated environments. We illustrate
                 this by tracing the evolution of three different
                 designs for a simple integrated environment as
                 representative changes are made to the requirements. We
                 present an approach that eases integration and
                 evolution by preserving tool independence in the face
                 of integration. We design tool integration
                 relationships as separate components called {\em
                 mediators}, and we design tools to implicitly invoke
                 mediators that integrate them. Mediators separate tools
                 from each other, while implicit invocation allows tools
                 to remain independent of mediators. To enable the use
                 of our approach on a range of platforms, we provide a
                 formalized model and requirements for implicit
                 invocation mechanisms. We apply this model both to
                 analyze existing mechanisms and in the design of a
                 mechanism for C++.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstract behavior type; behavior abstraction;
                 component independence; environment integration; event
                 mechanism; implicit invocation; integrated environment;
                 mediator; mediator/event design; software evolution;
                 tool integration",
  subject =      "Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf
                 Enhancement**}; Software --- Software Engineering ---
                 Design** (D.2.10): {\bf Methodologies**}; Computing
                 Milieux --- Management of Computing and Information
                 Systems --- Software Management (K.6.3): {\bf Software
                 development}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Extensibility**}; Computing Milieux --- Management
                 of Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software maintenance};
                 Software --- Software Engineering --- Programming
                 Environments (D.2.6); Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2); Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Assertions}; Software --- Software
                 Engineering --- Requirements/Specifications (D.2.1):
                 {\bf Methodologies (e.g., object-oriented,
                 structured)}",
}

@Article{Tyszberowicz:1992:OPL,
  author =       "Shmuel Tyszberowicz and Amiram Yehudai",
  title =        "{OBSERV} --- a prototyping language and environment",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "3",
  pages =        "269--309",
  month =        jul,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-3/p269-tyszberowicz/p269-tyszberowicz.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-3/p269-tyszberowicz/",
  abstract =     "The OBSERV methodology for software development is
                 based on rapid construction of an executable
                 specification, or prototype, of a systems, which may be
                 examined and modified repeatedly to achieve the desired
                 functionality. The objectives of OBSERV also include
                 facilitating a smooth transition to a target system,
                 and providing means for reusing specification, design,
                 and code of systems and subsystems. We are particularly
                 interested in handling embedded systems, which are
                 likely to have concurrency and have some real-time
                 requirements. \par

                 The OBSERV prototyping language combines several
                 paradigms to express the behavior of a system. The
                 object-oriented approach provides the basic mechanism
                 for building a system from a collection of objects,
                 with well-defined interfaces between them. We use
                 finite-state machines to model the behavior of
                 individual objects. At a lower level, activities that
                 occur within objects, either upon entry to a state or
                 in transition between thus allowing a nonprocedural
                 description. \par

                 The environment provided to a prototype builder is as
                 important as the language. We have made an attempt to
                 provide flexible tools for executing or simulating the
                 prototype being built, as well as for browsing and
                 static checking. The first implementation of the tools
                 was window based but not graphic. A graphic front end,
                 name CRUISE, was developed afterwards. \par

                 A simulation sequence focuses on a single object, which
                 can be as complex as necessary, possibly the entire
                 system, and expects all the interactions between it and
                 the outside world to be achieved by communication
                 between the simulator and the user. The simulator
                 allows the user to easily switch back and forth from
                 one object to another, simulating each object in
                 isolation. \par

                 To enable testing the behavior of a prototype in a
                 realistic environment, it is possible to construct
                 objects that imitate the environment objects. We also
                 allow simulation of systems with missing pieces, by
                 calling upon the user to simulate any such missing
                 piece by himself.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Documentation; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "browsers; concurrency; CRUISE; embedded systems;
                 graphical user interface; interactive programming
                 environments; logic programming; modeling with finite
                 state machines; object-oriented approach; OBSERV; real
                 time systems; simulator; software reuse; static
                 checker",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Software Engineering ---
                 Miscellaneous (D.2.m): {\bf Rapid prototyping**};
                 Software --- Software Engineering --- Miscellaneous
                 (D.2.m): {\bf Reusable software**}; Software ---
                 Programming Languages --- Language Classifications
                 (D.3.2): {\bf OBSERV}",
}

@Article{Yang:1992:PIA,
  author =       "Wuu Yang and Susan Horwitz and Thomas Reps",
  title =        "A program integration algorithm that accommodates
                 semantics-preserving transformations",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "3",
  pages =        "310--354",
  month =        jul,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-3/p310-yang/p310-yang.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-3/p310-yang/",
  abstract =     "Given a program {\em Base\/} and two variants, {\em
                 A\/} and {\em B}, each created by modifying separate
                 copies of {\em Base}, the goal of program integration
                 is to determine whether the modifications interfere,
                 and if they do not, to create an integrated program
                 that includes both sets of changes as well as the
                 portions of {\em Base\/} preserved in both variants.
                 Text-based integration techniques, such as the one used
                 by the Unix {\em diff 3\/} utility, are obviously
                 unsatisfactory because one has no guarantees about how
                 the execution behavior of the integrated program
                 relates to the behaviors of {\em Base}, {\em A}, and
                 {\em B}. The first program-integration algorithm to
                 provide such guarantees was developed by Horwitz et
                 al.[13]. However, a limitation of that algorithm is
                 that it incorporates no notion of semantics-preserving
                 transformations. This limitation causes the algorithm
                 to be overly conservative in its definition of
                 interference. For example, if one variant changes the
                 {\em way\/} a computation is performed (without
                 changing the values computed) while the other variant
                 adds code that uses the result of the computation, the
                 algorithm would classify those changes as interfering.
                 This paper describes a new integration algorithm that
                 is able to accommodate semantics-preserving
                 transformations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "coarsest partition; control dependence; data
                 dependence; data-flow analysis; flow dependence;
                 program dependence graph; program integration; program
                 representation graph; static-single-assignment form",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Programmer workbench**};
                 Software --- Software Engineering --- Coding Tools and
                 Techniques (D.2.3): {\bf Program editors}; Software ---
                 Software Engineering --- Programming Environments
                 (D.2.6); Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Enhancement**}; Software --- Software Engineering
                 --- Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Restructuring, reverse engineering, and
                 reengineering}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Version control}; Software --- Software
                 Engineering --- Management (D.2.9): {\bf Software
                 configuration management}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Interpreters}",
}

@Article{Batory:1992:DIH,
  author =       "Don Batory and Sean O'Malley",
  title =        "The design and implementation of hierarchical software
                 systems with reusable components",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "4",
  pages =        "355--398",
  month =        oct,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-4/p355-batory/p355-batory.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-4/p355-batory/",
  abstract =     "We present a domain-independent model of hierarchical
                 software system design and construction that is based
                 on interchangeable software components and large-scale
                 reuse. The model unifies the conceptualizations of two
                 independent projects, Genesis and Avoca, that are
                 successful examples of software
                 component/building-block technologies and domain
                 modeling. Building-block technologies exploit
                 large-scale reuse, rely on open architecture software,
                 and elevate the granularity of programming to the
                 subsystem level. Domain modeling formalizes the
                 similarities and differences among systems of a domain.
                 We believe our model is a blueprint for achieving
                 software component technologies in many domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Standardization",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "domain modeling; open system architectures; reuse;
                 software building-blocks; software design",
  subject =      "Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2): {\bf Protocol architecture}; Software ---
                 Programming Techniques --- Object-oriented Programming
                 (D.1.5); Software --- Software Engineering --- Design
                 Tools and Techniques (D.2.2): {\bf Modules and
                 interfaces}; Software --- Software Engineering ---
                 Design Tools and Techniques (D.2.2): {\bf Software
                 libraries}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Extensibility**}; Software --- Software
                 Engineering --- Design** (D.2.10): {\bf
                 Methodologies**}; Software --- Software Engineering ---
                 Design** (D.2.10): {\bf Representation**}; Software ---
                 Software Engineering --- Miscellaneous (D.2.m): {\bf
                 Rapid prototyping**}; Software --- Software Engineering
                 --- Miscellaneous (D.2.m): {\bf Reusable software**};
                 Computing Methodologies --- Simulation and Modeling ---
                 Model Development (I.6.5): {\bf Modeling
                 methodologies}",
}

@Article{Harel:1992:SO,
  author =       "David Harel and Chaim-arie Kahana",
  title =        "On statecharts with overlapping",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "4",
  pages =        "399--421",
  month =        oct,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-4/p399-harel/p399-harel.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-4/p399-harel/",
  abstract =     "The problem of extending the language of statecharts
                 to include overlapping states is considered. The need
                 for such an extension is motivated and the subtlety of
                 the problem is illustrated by exhibiting the
                 shortcomings of naive approaches. The syntax and formal
                 semantics of our extension are then presented, showing
                 in the process that the definitions for conventional
                 statecharts constitute a special case. Our definitions
                 are rather complex, a fact that we feel points to the
                 inherent difficulty of such an extension. We thus
                 prefer to leave open the question of whether or not it
                 should be adopted in practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "higraphs; reactive systems; statecharts; visual
                 language",
}

@Article{Zeil:1992:DLE,
  author =       "Steven J. Zeil and Faten H. Afifi and Lee J. White",
  title =        "Detection of linear errors via domain testing",
  journal =      j-TOSEM,
  volume =       "1",
  number =       "4",
  pages =        "422--451",
  month =        oct,
  year =         "1992",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1992-1-4/p422-zeil/p422-zeil.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1992-1-4/p422-zeil/",
  abstract =     "Domain testing attempts to find errors in the numeric
                 expressions affecting the flow of control through a
                 program. Intuitively, domain testing provides a
                 systematic form of boundary value testing for the
                 conditional statements within a program. Several forms
                 of domain testing have been proposed, all dealing with
                 the detection of linear errors in linear functions.
                 \par

                 Perturbation analysis has been previously developed as
                 a measure of the volume of faults, from within a
                 selected space of possible faults, left undetected by a
                 test set. It is adapted here to errors and error
                 spaces. The adapted form is used to show that the
                 different forms of domain testing are closer in error
                 detection ability than had been supposed. They may all
                 be considered effective for finding linear errors in
                 linear predicate functions. A simple extension is
                 proposed, which allows them to detect linear errors in
                 nonlinear predicate functions using only a single
                 additional test point.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "domain testing; perturbation testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Mathematics of Computing ---
                 Numerical Analysis --- Ordinary Differential Equations
                 (G.1.7): {\bf Boundary value problems}",
}

@Article{Broy:1993:FST,
  author =       "Manfred Broy",
  title =        "Functional specification of time-sensitive
                 communicating systems",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "1",
  pages =        "1--46",
  month =        jan,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-1/p1-broy/p1-broy.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-1/p1-broy/",
  abstract =     "A formal model and a logical framework for the
                 functional specification of time-sensitive
                 communicating systems and their interacting components
                 are outlined. The specification method is modular with
                 respect to sequential composition, parallel
                 composition, and communication feedback. Nondeterminism
                 is included by underspecification. The application of
                 the specification method to timed communicating
                 functions is demonstrated. Abstractions from time are
                 studied. In particular, a rational is given for the
                 chosen concepts of the functional specification
                 technique. The relationship between system models based
                 on nondeterminism and system models based on explicit
                 time notions is investigated. Forms of reasoning are
                 considered. The alternating bit protocol is used as a
                 running example.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Experimentation; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "functional system models; real-time systems;
                 specification",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4); Software --- Operating Systems
                 --- Organization and Design (D.4.7); Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1); Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2)",
}

@Article{Kaiser:1993:PDI,
  author =       "Gail E. Kaiser and Simon M. Kaplan",
  title =        "Parallel and distributed incremental attribute
                 evaluation algorithms for multiuser software
                 development environments",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "1",
  pages =        "47--92",
  month =        jan,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-1/p47-kaiser/p47-kaiser.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-1/p47-kaiser/",
  abstract =     "The problem of {\em change propagation\/} in multiuser
                 software development environments distributed across a
                 local-area network is addressed. The program is modeled
                 as an attributed parse tree segmented among multiple
                 user processes and changes are modeled as subtree
                 replacements requested asynchronously by individual
                 users. Change propagation is then implemented using
                 decentralized incremental evaluation of an attribute
                 grammar that defines the static semantic properties of
                 the programming language. Building up to our primary
                 result, we first present algorithms that support
                 parallel evaluation on a centralized tree in response
                 to single edits using a singe editing cursor and
                 multiple edits with multiple editing cursors. Then we
                 present our algorithm for parallel evaluation on a
                 decentralized tree. We also present a protocol to
                 guarantee reliability of the evaluation algorithm as
                 components of the decentralized tree become unavailable
                 due to failures and return to availability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Languages; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "attribute grammar; change propagation; distributed;
                 incremental algorithm; parallel; reliability",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6): {\bf Interactive environments};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Coding Tools and Techniques (D.2.3): {\bf Program
                 editors}; Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Semantics};
                 Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3)",
}

@Article{Whittaker:1993:MAS,
  author =       "James A. Whittaker and J. H. Poore",
  title =        "{Markov} analysis of software specifications",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "1",
  pages =        "93--106",
  month =        jan,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-1/p93-whittaker/p93-whittaker.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-1/p93-whittaker/",
  abstract =     "A procedure for modeling software usage with the
                 finite state, discrete parameter Markov chain is
                 described. It involves rigorous analysis of the
                 specification before design and coding begin. Many
                 benefits emerge from this process, including the
                 ability to synthesize a macro level usage distribution
                 from a micro level understanding of how the software
                 will be used. This usage distribution becomes the basis
                 for a statistical test of the software, which is
                 fundamental to the Cleanroom development process. Some
                 analytical results known for Markov chains that have
                 meaningful implications and interpretations for the
                 software development process are described.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management; Measurement; Reliability;
                 Standardization; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "box structure method; certification; Cleanroom; Markov
                 chain; software specification; statistical test;
                 stochastic process; usage distribution",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Mathematics of
                 Computing --- Probability and Statistics (G.3);
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}; Software --- Software
                 Engineering --- Metrics (D.2.8): {\bf Complexity
                 measures}; Software --- Software Engineering ---
                 Management (D.2.9): {\bf Software quality assurance
                 (SQA)}; Computing Methodologies --- Simulation and
                 Modeling --- Model Development (I.6.5): {\bf Modeling
                 methodologies}",
}

@Article{DeMillo:1993:ERA,
  author =       "Richard A. DeMillo and A. Jefferson Offutt",
  title =        "Experimental results from an automatic test case
                 generator",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "2",
  pages =        "109--127",
  month =        apr,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-2/p109-demillo/p109-demillo.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-2/p109-demillo/",
  abstract =     "Constraint-based testing is a novel way of generating
                 test data to detect specific types of common
                 programming faults. The conditions under which faults
                 will be detected are encoded as mathematical systems of
                 constraints in terms of program symbols. A set of
                 tools, collectively called Godzilla, has been
                 implemented that automatically generates constraint
                 systems and solves them to create test cases for use by
                 the Mothra testing system. Experimental results from
                 using Godzilla show that the technique can produce test
                 data that is very close in terms of mutation adequacy
                 to test data that is produced manually, and at
                 substantially reduced cost. Additionally, these
                 experiments have suggested a new procedure for unit
                 testing, where test cases are viewed as throw-away
                 items rather than scarce resources.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Measurement; Performance;
                 Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "adequacy; constraints; mutation analysis",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}",
}

@Article{Feldman:1993:SRS,
  author =       "Yishai A. Feldman and Haim Schneider",
  title =        "Simulating reactive systems by deduction",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "2",
  pages =        "128--175",
  month =        apr,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-2/p128-feldman/p128-feldman.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-2/p128-feldman/",
  abstract =     "Debugging is one of the main uses of simulation.
                 Localizing bugs or finding the reasons for unclear
                 behavior involves going backwards in time, whereas
                 simulation goes forward in time. Therefore, identifying
                 causes with the aid of most existing simulation tools
                 usually requires repeating the simulation several
                 times, each time with reduced holes in the sieve. An
                 alternative is simulation by deduction, a technique in
                 which the steps in the dynamic behavior of the
                 simulated model are deduced by a reasoning system. A
                 simulation system that uses simulation by deduction can
                 give direct answers to questions about the reasons for
                 the simulation results. By recording the support for
                 its deductions, such a system can answer ``why'' and
                 ``why not'' questions about the scenario. \par

                 Another benefit of simulation by deduction is that it
                 enables symbolic simulation, that is, simulating a
                 scenario given only a partial description of the
                 environment and the simulated model. This allows
                 verifying properties of an evolving design at any stage
                 of the design process, and thus checking the
                 consequences of the design decisions made so far. In
                 order to allow deducing as much as possible from
                 partial information, the axiom system has to be
                 minimalistic, i.e., axioms have to require the minimum
                 amount of knowledge of simulation inputs. \par

                 These ideas were implemented in a system called SIP,
                 which simulates the behavior of reactive systems. SIP
                 is capable of answering ``why,'' ``why not,'' and
                 ``what if'' questions. It also has a limited capability
                 of dealing with partial knowledge. SIP is based on a
                 reasoning system that is responsible for deducing the
                 effects of the external inputs on the state of the
                 simulated model, and recording the support for its
                 deductions. The logical basis for the deduction of a
                 step in SIP is provided by a minimalistic axiom system
                 for statecharts. \par

                 Although SIP simulates reactive systems described as
                 statecharts, the principle of simulation by deduction
                 is applicable to other types of systems and
                 descriptions, provided only that they have a
                 well-defined formal semantics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Computing Methodologies --- Artificial Intelligence
                 --- Deduction and Theorem Proving (I.2.3): {\bf
                 Deduction}; Computing Methodologies --- Simulation and
                 Modeling --- Simulation Support Systems (I.6.7): {\bf
                 Environments}; Computer Applications --- Computers in
                 Other Systems (J.7)",
}

@Article{Klint:1993:MEG,
  author =       "P. Klint",
  title =        "A meta-environment for generating programming
                 environments",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "2",
  pages =        "176--201",
  month =        apr,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-2/p176-klint/p176-klint.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-2/p176-klint/",
  abstract =     "Over the last decade, considerable progress has been
                 made in solving the problems of automatic generation of
                 programming/development environments, given a formal
                 definition of some programming or specification
                 language. In most cases, research has focused on the
                 functionality and efficiency of the generated
                 environments, and, of course, these aspects will
                 ultimately determine the acceptance of environment
                 generators. However, only marginal attention has been
                 paid to the development process of formal language
                 definitions itself. Assuming that the quality of
                 automatically generated environments will be
                 satisfactory within a few years, the development costs
                 of formal language definitions will then become the
                 next limiting factor determining ultimate success and
                 acceptance of environment generators. \par

                 In this paper we describe the design and implementation
                 of a meta-environment (a development environment for
                 formal language definitions) based on the formalism ASF
                 + SDF. This meta-environment is currently being
                 implemented as part of the Centaur system and is, at
                 least partly, obtained by applying environment
                 generation techniques to the language definition
                 formalism itself. A central problem is providing fully
                 interactive editing of modular language definitions
                 such that modifications made to the language definition
                 during editing can be translated immediately to
                 modifications in the programming environment generated
                 from the original language definition. Therefore, some
                 of the issues addressed are the treatment of formalisms
                 with user-definable syntax and incremental program
                 generation techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Methodologies ---
                 Artificial Intelligence --- Automatic Programming
                 (I.2.2); Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1)",
}

@Article{Ciancarini:1993:CRB,
  author =       "Paolo Ciancarini",
  title =        "Coordinating rule-based software processes with
                 {ESP}",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "3",
  pages =        "203--227",
  month =        jul,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-3/p203-ciancarini/p203-ciancarini.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-3/p203-ciancarini/",
  abstract =     "ESP is a language for modeling rule-based software
                 processes that take place in a distributed software
                 development environment. It is based on PoliS, an
                 abstract coordination model that relies on Multiple
                 Tuple Spaces, i.e., collections of tuples a la Linda.
                 PoliS extends Linda aiming at the specification and
                 coordination of logically distributed systems. ESP
                 (Extended Shared Prolog) combines the PoliS mechanisms
                 to deal with concurrency and distribution, with the
                 logic-programming language Prolog, to deal with rules
                 and deduction. Such a combination of a coordination
                 model and a logic language provides a powerful
                 framework in which experiments about rule-based
                 software process programming can be performed and
                 evaluated.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concurrency; logic programming; multiuser programming
                 environment; rule-based programming; software process;
                 software process modeling",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3); Software --- Software Engineering
                 --- Programming Environments (D.2.6); Computing
                 Methodologies --- Artificial Intelligence --- Deduction
                 and Theorem Proving (I.2.3): {\bf Deduction}; Software
                 --- Programming Languages --- Language Classifications
                 (D.3.2): {\bf Concurrent, distributed, and parallel
                 languages}; Computing Methodologies --- Artificial
                 Intelligence --- Deduction and Theorem Proving (I.2.3):
                 {\bf Logic programming}; Computing Milieux ---
                 Management of Computing and Information Systems ---
                 Software Management (K.6.3): {\bf Software
                 development}; Computing Methodologies --- Simulation
                 and Modeling --- Applications (I.6.3); Software ---
                 Software Engineering --- Design** (D.2.10): {\bf
                 Methodologies**}; Software --- Software Engineering ---
                 Management (D.2.9)",
}

@Article{Griswold:1993:AAP,
  author =       "William G. Griswold and David Notkin",
  title =        "Automated assistance for program restructuring",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "3",
  pages =        "228--269",
  month =        jul,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-3/p228-griswold/p228-griswold.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-3/p228-griswold/",
  abstract =     "Maintenance tends to degrade the structure of
                 software, ultimately making maintenance more costly. At
                 times, then, it is worthwhile to manipulate the
                 structure of a system to make changes easier. However,
                 manual restructuring is an error-prone and expensive
                 activity. By separating structural manipulations from
                 other maintenance activities, the semantics of a system
                 can be held constant by a tool, assuring that no errors
                 are introduced by restructuring. To allow the
                 maintenance team to focus on the aspects of
                 restructuring and maintenance requiring human judgment,
                 a transformation-based tool can be provided--based on a
                 model that exploits preserving data flow dependence and
                 control flow dependence--to automate the repetitive,
                 error-prone, and computationally demanding aspects of
                 restructuring. A set of automatable transformations is
                 introduced; their impact on structure is described, and
                 their usefulness is demonstrated in examples. A model
                 to aid building meaning-preserving restructuring
                 transformations is described, and its realization in a
                 functioning prototype tool for restructuring Scheme
                 programs is discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "CASE; flow analysis; meaning-preserving
                 transformations; software engineering; software
                 evolution; software maintenance; software
                 restructuring; source-level restructuring",
  subject =      "Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf
                 Restructuring, reverse engineering, and reengineering};
                 Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf
                 Corrections**}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Enhancement**}; Software --- Software Engineering
                 --- Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Extensibility**}; Software --- Software
                 Engineering --- Design** (D.2.10); Computing Milieux
                 --- Management of Computing and Information Systems ---
                 Software Management (K.6.3): {\bf Software
                 maintenance}; Software --- Software Engineering ---
                 Design Tools and Techniques (D.2.2): {\bf
                 Computer-aided software engineering (CASE)}; Computing
                 Methodologies --- Artificial Intelligence --- Automatic
                 Programming (I.2.2): {\bf Program transformation}",
}

@Article{Harrold:1993:MCS,
  author =       "M. Jean Harrold and Rajiv Gupta and Mary Lou Soffa",
  title =        "A methodology for controlling the size of a test
                 suite",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "3",
  pages =        "270--285",
  month =        jul,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-3/p270-harrold/p270-harrold.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-3/p270-harrold/",
  abstract =     "This paper presents a technique to select a
                 representative set of test cases from a test suite that
                 provides the same coverage as the entire test suite.
                 This selection is performed by identifying, and then
                 eliminating, the redundant and obsolete test cases in
                 the test suite. The representative set replaces the
                 original test suite and thus, potentially produces a
                 smaller test suite. The representative set can also be
                 used to identify those test cases that should be rerun
                 to test the program after it has been changed. Our
                 technique is independent of the testing methodology and
                 only requires an association between a testing
                 requirement and the test cases that satisfy the
                 requirement. We illustrate the technique using the data
                 flow testing methodology. The reduction that is
                 possible with our technique is illustrated by
                 experimental results.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Experimentation; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "hitting set; regression testing; software engineering;
                 software maintenance; test suite reduction",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Software --- Software Engineering
                 --- Design** (D.2.10): {\bf Methodologies**}; Software
                 --- Software Engineering --- Distribution, Maintenance,
                 and Enhancement (D.2.7): {\bf Version control}",
}

@Article{Podgurski:1993:RRS,
  author =       "Andy Podgurski and Lynn Pierce",
  title =        "Retrieving reusable software by sampling behavior",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "3",
  pages =        "286--303",
  month =        jul,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-3/p286-podgurski/p286-podgurski.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-3/p286-podgurski/",
  abstract =     "A new method, called {\em behavior sampling}, is
                 proposed for automated retrieval of reusable components
                 from software libraries. Behavior sampling exploits the
                 property of software that distinguished it from other
                 forms of test: executability. Basic behavior sampling
                 identifies relevant routines by executing candidates on
                 a searcher-supplied sample of operational inputs and by
                 comparing their output to output provided by the
                 searcher. The probabilistic basis for behavior sampling
                 is described, and experimental results are reported
                 that suggest that basic behavior sampling exhibits high
                 precision when used with small samples. Extensions to
                 basic behavior sampling are proposed to improve its
                 recall and to make it applicable to the retrieval of
                 abstract data types and object classes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Experimentation",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "behavior sampling; software libraries; software
                 retrieval; software reuse",
  subject =      "Software --- Software Engineering --- Miscellaneous
                 (D.2.m): {\bf Reusable software**}; Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2): {\bf Software libraries}; Software ---
                 Software Engineering --- Distribution, Maintenance, and
                 Enhancement (D.2.7); Information Systems ---
                 Information Storage and Retrieval --- Information
                 Search and Retrieval (H.3.3)",
}

@Article{Dillon:1993:VEM,
  author =       "Laura K. Dillon",
  title =        "A visual execution model for {Ada} tasking",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "4",
  pages =        "311--345",
  month =        oct,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-4/p311-dillon/p311-dillon.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-4/p311-dillon/",
  abstract =     "A visual execution model for Ada tasking can help
                 programmers attain a deeper understanding of the
                 tasking semantics. It can illustrate subtleties in
                 semantic definitions that are not apparent in natural
                 language design. We describe a contour model of Ada
                 tasking that depicts asynchronous tasks (threads of
                 control), relationships between the environments in
                 which tasks execute, and the manner in which tasks
                 interact. The use of this high-level execution model
                 makes it possible to see what happens during execution
                 of a program. The paper provides an introduction to the
                 contour model of Ada tasking and demonstrates its
                 use.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "contour model; visual execution model",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Software Engineering
                 --- Programming Environments (D.2.6); Software ---
                 Programming Languages --- Formal Definitions and Theory
                 (D.3.1): {\bf Semantics}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Ada}; Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Concurrent
                 programming structures}; Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3); Theory
                 of Computation --- Logics and Meanings of Programs ---
                 Semantics of Programming Languages (F.3.2): {\bf
                 Operational semantics}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Interpreters}",
}

@Article{Wang:1993:DRT,
  author =       "Farn Wang and Aloysius K. Mok and E. Allen Emerson",
  title =        "Distributed real-time system specification and
                 verification in {APTL}",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "4",
  pages =        "346--378",
  month =        oct,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-4/p346-wang/p346-wang.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-4/p346-wang/",
  abstract =     "In this article, we propose a language, Asynchronous
                 Propositional Temporal Logic (APTL), for the
                 specification and verification of distributed hard
                 real-time systems. APTL extends the logic TPTL by
                 dealing explicitly with multiple local clocks. We
                 propose a distributed-system model which permits
                 definition of inequalities asserting the temporal
                 precedence of local clock readings. We show the
                 expressiveness of APTL through two nontrivial examples.
                 Our logic can be used to specify and reason about such
                 important properties as bounded clock rate drifting. We
                 then give a 2 2 0(n) tableau-based decision procedure
                 for determining APTL satisfiability, where {\em n\/} is
                 the size (number of bits) of the input formula.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "asynchronous; bounded clock rate drifting; multiclock
                 system model; propositional temporal logic; real-time
                 systems; specification; verification",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Operating Systems --- Organization and
                 Design (D.4.7): {\bf Real-time systems and embedded
                 systems}; Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Semantics}",
}

@Article{Zave:1993:CC,
  author =       "Pamela Zave and Michael Jackson",
  title =        "Conjunction as composition",
  journal =      j-TOSEM,
  volume =       "2",
  number =       "4",
  pages =        "379--411",
  month =        oct,
  year =         "1993",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1993-2-4/p379-zave/p379-zave.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1993-2-4/p379-zave/",
  abstract =     "Partial specifications written in many different
                 specification languages can be composed if they are all
                 given semantics in the same domain, or alternatively,
                 all translated into a common style of predicate logic.
                 The common semantic domain must be very general, the
                 particular semantics assigned to each specification
                 language must be conducive to composition, and there
                 must be some means of communication that enables
                 specifications to build on one another. The criteria
                 for success are that a wide variety of specification
                 languages should be accommodated, there should be no
                 restrictions on where boundaries between languages can
                 be placed, and intuitive expectations of the specifier
                 should be met.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "compositional specification; multiparadigm
                 specification; practical specification",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}",
}

@Article{Adams:1994:CSR,
  author =       "Rolf Adams and Walter Tichy and Annette Weinert",
  title =        "The cost of selective recompilation and environment
                 processing",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "1",
  pages =        "3--28",
  month =        jan,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See comment \cite{Brett:1995:CCS,Tichy:1995:AR}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-1/p3-adams/p3-adams.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-1/p3-adams/",
  abstract =     "When a single software module in a large system is
                 modified, a potentially large number of other modules
                 may have to be recompiled. By reducing both the number
                 of compilations and the amount of input processed by
                 each compilation run, the turnaround time after changes
                 can be reduced significantly. \par

                 Potential time savings are measured in a medium-sized,
                 industrial software project over a three-year period.
                 The results indicate that a large number of
                 compilations caused by traditional compilation unit
                 dependencies may be redundant. On the available data, a
                 mechanism that compares compiler output saves about 25
                 percent, smart recompilation saves 50 percent, and
                 smartest recompilation may save up to 80 percent of
                 compilation work. \par

                 Furthermore, all compilation methods other than
                 smartest recompilation process large amounts of unused
                 environment data. In the project analyzed, the average
                 environment symbols are actually used. Reading only the
                 actually used symbols would reduce total compiler input
                 by about 50 percent. \par

                 Combining smart recompilation with a reduction in
                 environment processing might double to triple perceived
                 compilation speed and double linker speed, without
                 sacrificing static type safety.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "empirical analysis; environment processing; selective
                 recompilation; separate compilation; smart
                 recompilation; software evolution",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Software --- Software Engineering
                 --- Management (D.2.9): {\bf Software configuration
                 management}; Software --- Programming Languages ---
                 Processors (D.3.4); Software --- Programming Languages
                 --- Processors (D.3.4): {\bf Compilers}",
}

@Article{Forgacs:1994:DIF,
  author =       "Istv{\'a}n Forg{\'a}cs",
  title =        "Double iterative framework for flow-sensitive
                 interprocedural data flow analysis",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "1",
  pages =        "29--55",
  month =        jan,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-1/p29-forgacs/p29-forgacs.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-1/p29-forgacs/",
  abstract =     "Compiler optimization, parallel processing, data flow
                 testing, and symbolic debugging can benefit from
                 interprocedural data flow analysis. However, the live,
                 reaching definition, and most summary data flow
                 problems are theoretically intractable in the
                 interprocedural case. A method is presented that
                 reduces the exponential time bound with the help of an
                 algorithm that solves the problem in polynomial time.
                 Either the resulting sets contain precise results or
                 the missing (or additional) results do not cause any
                 problems during their use. We also introduce the double
                 iterative framework, where one procedure is processed
                 at a time. The results of the intraprocedural analysis
                 of procedures then propagates along the edges of the
                 call multi-graph. In this way the intra and
                 interprocedural analyses are executed alternately until
                 there is no change in any result set. This method can
                 be applied to any known interprocedural data flow
                 problem. Here the algorithms for the kill, live
                 variables, and reaching definitions problems are
                 presented. Besides for precision, the algorithms can be
                 used for very large programs, and since inter and
                 intraprocedural analyses can be optimized separately,
                 the method is fast as well.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "data flow analysis; double iterative frameworks",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Data --- Files (E.5); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}",
}

@Article{Morzenti:1994:OOL,
  author =       "Angelo Morzenti and Pierluigi {San Pietro}",
  title =        "Object-oriented logical specification of time-critical
                 systems",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "1",
  pages =        "56--98",
  month =        jan,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-1/p56-morzenti/p56-morzenti.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-1/p56-morzenti/",
  abstract =     "We define TRIO +, an object-oriented logical language
                 for modular system specification. TRIO + is based on
                 TRIO, a first-order temporal language that is well
                 suited to the specification of embedded and real-time
                 systems, and that provides an effective support to a
                 variety of validation activities, like specification
                 testing, simulation, and property proof. Unfortunately,
                 TRIO lacks the ability to construct specifications of
                 complex systems in a systematic and modular way. TRIO +
                 combines the use of constructs for hierarchical system
                 decomposition and object-oriented concepts like
                 inheritance and genericity with an expressive and
                 intuitive graphic notation, yielding a specification
                 language that is formal and rigorous, yet still
                 flexible, readable, general, and easily adaptable to
                 the user's needs. After introducing and motivating the
                 main features of the language, we illustrate its
                 application to a nontrivial case study extracted from a
                 real-life industrial application.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Measurement; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "first-order logic; formal specifications;
                 model-theoretic semantics; object-oriented
                 methodologies; real-time systems; temporal logic",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Tools}; Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf Modules
                 and interfaces}; Software --- Software Engineering ---
                 Design Tools and Techniques (D.2.2): {\bf Software
                 libraries}; Software --- Operating Systems ---
                 Organization and Design (D.4.7): {\bf Real-time systems
                 and embedded systems}; Software --- Software
                 Engineering --- Requirements/Specifications (D.2.1):
                 {\bf TRIO+}",
}

@Article{Doong:1994:AAT,
  author =       "Roong-Ko Doong and Phyllis G. Frankl",
  title =        "The {ASTOOT} approach to testing object-oriented
                 programs",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "2",
  pages =        "101--130",
  month =        apr,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-2/p101-doong/p101-doong.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-2/p101-doong/",
  abstract =     "This article describes a new approach to the unit
                 testing of object-oriented programs, a set of tools
                 based on this approach, and two case studies. In this
                 approach, each test case consists of a tuple of
                 sequences of messages, along with tags indicating
                 whether these sequences should put objects of the class
                 under test into equivalent states and/or return objects
                 that are in equivalent states. Tests are executed by
                 sending the sequences to objects of the class under
                 test, then invoking a user-supplied
                 equivalence-checking mechanism. This approach allows
                 for substantial automation of many aspects of testing,
                 including test case generation, test driver generation,
                 test execution, and test checking. Experimental
                 prototypes of tools for test generation and test
                 execution are described. The test generation tool
                 requires the availability of an algebraic specification
                 of the abstract data type being tested, but the test
                 execution tool can be used when no formal specification
                 is available. Using the test execution tools, case
                 studies involving execution of tens of thousands of
                 test cases, with various sequence lengths, parameters,
                 and combinations of operations were performed. The
                 relationships among likelihood of detecting an error
                 and sequence length, range of parameters, and relative
                 frequency of various operations were investigated for
                 priority queue and sorted-list implementations having
                 subtle errors. In each case, long sequences tended to
                 be more likely to detect the error, provided that the
                 range of parameters was sufficiently large and
                 likelihood of detecting an error tended to increase up
                 to a threshold value as the parameter range
                 increased.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Languages; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstract data types; algebraic specification;
                 object-oriented programming; software testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}; Software --- Software
                 Engineering --- Requirements/Specifications (D.2.1):
                 {\bf Languages}; Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Object-oriented
                 languages}; Software --- Software Engineering ---
                 Testing and Debugging (D.2.5): {\bf Symbolic
                 execution}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf Abstract
                 data types}",
}

@Article{Dillon:1994:GIL,
  author =       "L. K. Dillon and G. Kutty and L. E. Moser and P. M.
                 Melliar-Smith and Y. S. Ramakrishna",
  title =        "A graphical interval logic for specifying concurrent
                 systems",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "2",
  pages =        "131--165",
  month =        apr,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-2/p131-dillon/p131-dillon.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-2/p131-dillon/",
  abstract =     "This article describes a graphical interval logic that
                 is the foundation of a tool set supporting formal
                 specification and verification of concurrent software
                 systems. Experience has shown that most software
                 engineers find standard temporal logics difficult to
                 understand and use. The objective of this article is to
                 enable software engineers to specify and reason about
                 temporal properties of concurrent systems more easily
                 by providing them with a logic that has an intuitive
                 graphical representation and with tools that support
                 its use. To illustrate the use of the graphical logic,
                 the article provides some specifications for an
                 elevator system and proves several properties of the
                 specifications. The article also describes the tool set
                 and the implementation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Human Factors; Languages; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automated proof-checking; concurrent systems; formal
                 specifications; graphical interval logic; temporal
                 logic; timing diagrams; visual languages",
  subject =      "Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Specification techniques};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Mechanical verification};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Tools};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2)",
}

@Article{Parisi-Presicce:1994:ATC,
  author =       "Francesco Parisi-Presicce and Alfonso Pierantonio",
  title =        "An algebraic theory of class specification",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "2",
  pages =        "166--199",
  month =        apr,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-2/p166-parisi-presicce/p166-parisi-presicce.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-2/p166-parisi-presicce/",
  abstract =     "The notion of class (or object pattern) as defined in
                 most object-oriented languages is formalized using
                 known techniques from algebraic specifications.
                 Inheritance can be viewed as a relation between
                 classes, which suggests how classes can be arranged in
                 hierarchies. The hierarchies contain two kinds of
                 information: on the one hand, they indicate how
                 programs are structured and how code is shared among
                 classes; on the other hand, they give information about
                 compatible assignment rules, which are based on
                 subtyping. In order to distinguish between code
                 sharing, which is related to implementational aspects,
                 and functional specialization, which is connected to
                 the external behavior of objects, we introduce an
                 algebraic specification-based formalism, by which one
                 can specify the behavior of a class and state when a
                 class inherits another one. It is shown that reusing
                 inheritance can be reduced to specialization
                 inheritance with respect to a virtual class. The class
                 model and the two distinct aspects of inheritance allow
                 the definition of {\em clean\/} interconnection
                 mechanisms between classes leading to new classes which
                 inherit from old classes their correctness and their
                 semantics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "algebraic specifications; inheritance; interconnection
                 mechanisms; modularity",
  subject =      "Software --- Programming Techniques ---
                 Object-oriented Programming (D.1.5); Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Methodologies (e.g., object-oriented,
                 structured)}; Software --- Software Engineering ---
                 Design** (D.2.10): {\bf Methodologies**}; Software ---
                 Programming Languages --- Formal Definitions and Theory
                 (D.3.1); Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf Abstract
                 data types}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf Modules,
                 packages}; Theory of Computation --- Logics and
                 Meanings of Programs --- Semantics of Programming
                 Languages (F.3.2): {\bf Algebraic approaches to
                 semantics}",
}

@Article{Bernhard:1994:RTS,
  author =       "Philip J. Bernhard",
  title =        "A reduced test suite for protocol conformance
                 testing",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "3",
  pages =        "201--220",
  month =        jul,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See comments \cite{Petrenko:1997:CRT}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-3/p201-bernhard/p201-bernhard.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-3/p201-bernhard/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Reliability; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "heuristics",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2); Computer Systems Organization --- Performance
                 of Systems (C.4)",
}

@Article{Cheon:1994:LSI,
  author =       "Yoonsik Cheon and Gary T. Leavens",
  title =        "The {Larch\slash Smalltalk} interface specification
                 language",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "3",
  pages =        "221--253",
  month =        jul,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-3/p221-cheon/p221-cheon.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-3/p221-cheon/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Documentation; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal methods; interface specification;
                 Larch/Smalltalk; Smalltalk; specification inheritance;
                 subtype; verification",
  subject =      "Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Larch}; Software ---
                 Programming Languages --- Language Classifications
                 (D.3.2): {\bf Smalltalk}; Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2);
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Assertions}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Invariants}; Theory of Computation ---
                 Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1): {\bf
                 Pre- and post-conditions}; Theory of Computation ---
                 Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1): {\bf
                 Specification techniques}",
}

@Article{Jeng:1994:SDT,
  author =       "Bingchiang Jeng and Elaine J. Weyuker",
  title =        "A simplified domain-testing strategy",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "3",
  pages =        "254--270",
  month =        jul,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-3/p254-jeng/p254-jeng.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-3/p254-jeng/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "domain testing; software testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5)",
}

@Article{Creveuil:1994:FSD,
  author =       "Christian Creveuil and Gruia-Catalin Roman",
  title =        "Formal specification and design of a message router",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "4",
  pages =        "271--307",
  month =        oct,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-4/p271-creveuil/p271-creveuil.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-4/p271-creveuil/",
  abstract =     "Formal derivation refers to a family of design
                 techniques that entail the development of programs
                 which are guaranteed to be correct by construction.
                 Only limited industrial use of such techniques (e.g.,
                 UNITY-style specification refinement) has been reported
                 in the literature, and there is a great need for
                 methodological developments aimed at facilitating their
                 application to complex problems. This article examines
                 the formal specification and design of a message router
                 in an attempt to identify those methodological elements
                 that are likely to contribute to successful industrial
                 uses of program derivation. Although the message router
                 cannot be characterized as being industrial grade, it
                 is a sophisticated problem that poses significant
                 specification and design challenges--its apparent
                 simplicity is rather deceiving. The main body of the
                 article consists of a complete formal specification of
                 the router and a series of successive refinements that
                 eventually lead to an immediate construction of a
                 correct UNITY program. Each refinement is accompanied
                 by its design rationale and is explained in a manner
                 accessible to a broad audience. We use this example to
                 make the case that program derivation provides a good
                 basis for introducing rigor in the design strategy,
                 regardless of the degrees of formality one is willing
                 to consider.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal methods; program derivation; specification
                 refinement; UNITY",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3): {\bf Distributed programming};
                 Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3): {\bf Parallel programming};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Software/Program Verification
                 (D.2.4): {\bf Correctness proofs}; Software ---
                 Software Engineering --- Design** (D.2.10): {\bf
                 Methodologies**}",
}

@Article{Felder:1994:VRT,
  author =       "Miguel Felder and Angelo Morzenti",
  title =        "Validating real-time systems by history-checking
                 {TRIO} specifications",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "4",
  pages =        "308--339",
  month =        oct,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-4/p308-felder/p308-felder.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-4/p308-felder/",
  abstract =     "We emphasize the importance of formal executable
                 specifications in the development of real-time systems,
                 as a means to assess the adequacy of the requirements
                 before a costly development process takes place. TRIO
                 is a first-order temporal logic language for executable
                 specification of real-time systems that deals with time
                 in a quantitative way by providing a metric to indicate
                 distance in time between events and length of time
                 intervals. We summarize the language and its
                 model-parametric semantics. Then we present an
                 algorithm to perform history checking, i.e., to check
                 that a history of the system satisfies the
                 specification. This algorithm can be used as a basis
                 for an effective specification testing tool. The
                 algorithm is described; an estimation of its complexity
                 is provided; and the main functionalities of the tool
                 are presented, together with sample test cases.
                 Finally, we draw conclusions and indicate directions of
                 future research.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "first-order logic; formal specifications;
                 model-theoretic semantics; requirements validation",
  subject =      "Computer Systems Organization --- Special-Purpose and
                 Application-Based Systems (C.3): {\bf Real-time and
                 embedded systems}; Software --- Software Engineering
                 --- Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Software/Program Verification
                 (D.2.4): {\bf Validation}; Software --- Operating
                 Systems --- Organization and Design (D.4.7): {\bf
                 Real-time systems and embedded systems}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Mechanical verification}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Specification techniques}",
}

@Article{Duri:1994:AEE,
  author =       "S. Duri and U. Buy and R. Devarapalli and S. M.
                 Shatz",
  title =        "Application and experimental evaluation of state space
                 reduction methods for deadlock analysis in {Ada}",
  journal =      j-TOSEM,
  volume =       "3",
  number =       "4",
  pages =        "340--380",
  month =        oct,
  year =         "1994",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1994-3-4/p340-duri/p340-duri.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1994-3-4/p340-duri/",
  abstract =     "An emerging challenge for software engineering is the
                 development of the methods and tools to aid design and
                 analysis of concurrent and distributed software. Over
                 the past few years, a number of analysis methods that
                 focus on Ada tasking have been developed. Many of these
                 methods are based on some form of reachability
                 analysis, which has the advantage of being conceptually
                 simple, but the disadvantage of being computationally
                 expensive. We explore the effectiveness of various
                 Petri net-based techniques for the automated deadlock
                 analysis of Ada programs. Our experiments consider a
                 variety of state space reduction methods both
                 individually and in various combinations. The
                 experiments are applied to a number of classical
                 concurrent programs as well as a set of ``real-world''
                 programs. The results indicate that Petri net reduction
                 and reduced state space generation are mutually
                 beneficial techniques, and that combined approaches
                 based on Petri net models are quite effective, compared
                 to alternative analysis approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Ada tasking; automatic analysis; concurrency analysis;
                 deadlock detection; experimental evaluation; state
                 space explosion",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3): {\bf Distributed programming};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf Petri
                 nets}; Software --- Software Engineering --- Testing
                 and Debugging (D.2.5): {\bf Debugging aids}",
}

@Article{Binkley:1995:PIL,
  author =       "David Binkley and Susan Horwitz and Thomas Reps",
  title =        "Program integration for languages with procedure
                 calls",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "1",
  pages =        "3--35",
  month =        jan,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-1/p3-binkley/p3-binkley.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-1/p3-binkley/",
  abstract =     "Given a program Base and two variants, A and B, each
                 created by modifying separate copies of Base, the goal
                 of program integration is to determine whether the
                 modifications interfere, and if they do not, to create
                 an integrated program that incorporates both sets of
                 changes as well as the portions of Base preserved in
                 both variants. Text-based integration techniques, such
                 as the one used by the Unix {\em diff3\/} utility, are
                 obviously unsatisfactory because one has no guarantees
                 about how the execution behavior of the integrated
                 program relates to the behaviors of Base, A, and B. The
                 first program integration algorithm to provide such
                 guarantees was developed by Horwitz, Prins, and Reps.
                 However, a limitation of that algorithm is that it only
                 applied to programs written in a restricted
                 language--in particular, the algorithm does not handle
                 programs with procedures. This article describes a
                 generalization of the Horwitz-Prins-Reps algorithm that
                 handles programs that consist of multiple (and possibly
                 mutually recursive) procedures. \par

                 We show that two straightforward generalizations of the
                 Horwitz-Prins-Reps algorithm yield unsatisfactory
                 results. The key issue in developing a satisfactory
                 algorithm is how to take into account different calling
                 contexts when determining what has changed in the
                 variants A and B. Our solution to this problem involves
                 identifying two different kinds of affected components
                 of A and B: those affected regardless of how the
                 procedure is called, and those affected by a changed or
                 new calling context. The algorithm makes use of
                 interprocedural program slicing to identify these
                 components, as well as components in Base, A, and B
                 with the same behavior.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Languages; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "control dependence; data dependence; data-flow
                 analysis; flow-insensitive summary information; program
                 dependence graph; program slicing; semantics-based
                 program integration",
  subject =      "Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf Version
                 control}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Restructuring, reverse engineering, and
                 reengineering}; Software --- Software Engineering ---
                 Management (D.2.9); Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf
                 Programmer workbench**}; Software --- Software
                 Engineering --- Coding Tools and Techniques (D.2.3):
                 {\bf Program editors}; Software --- Programming
                 Languages --- Language Constructs and Features (D.3.3);
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}",
}

@Article{Howden:1995:STA,
  author =       "W. E. Howden and Yudong Huang",
  title =        "Software trustability analysis",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "1",
  pages =        "36--64",
  month =        jan,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-1/p36-howden/p36-howden.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-1/p36-howden/",
  abstract =     "A measure of software dependability called
                 trustability is described. A program p has trustability
                 T if we are at least T confident that p is free of
                 faults. Trustability measurement depends on
                 detectability. The detectability of a method is the
                 probability that it will detect faults, when there are
                 faults present. Detectability research can be used to
                 characterize conditions under which one testing and
                 analysis method is more effective than another. Several
                 detectability results that were only previously
                 described informally, and illustrated by example, are
                 proved. Several new detectability results are also
                 proved. The trustability model characterizes the kind
                 of information that is needed to justify a given level
                 of trustability. When the required information is
                 available, the trustability approach can be used to
                 determine strategies in which methods are combined for
                 maximum effectiveness. It can be used to determine the
                 minimum amount of resources needed to guarantee a
                 required degree of trustability, and the maximum
                 trustability that is achievable with a given amount of
                 resources. Theorems proving several optimization
                 results are given. Applications of the trustability
                 model are discussed. Methods for the derivation of
                 detectability factors, the relationship between
                 trustability and operational reliability, and the
                 relationship between the software development process
                 and trustability are described.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "analysis; dependability; detectability; failure
                 density; statistical; testability; testing;
                 trustability",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1)",
}

@Article{Young:1995:CAT,
  author =       "Michal Young and Richard N. Taylor and David L. Levine
                 and Kari A. Nies and Debra Brodbeck",
  title =        "A concurrency analysis tool suite for {Ada} programs:
                 rationale, design, and preliminary experience",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "1",
  pages =        "65--106",
  month =        jan,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-1/p65-young/p65-young.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-1/p65-young/",
  abstract =     "Cats (Concurrency Analysis Tool Suite) is designed to
                 satisfy several criteria: it must analyze
                 implementation-level Ada source code and check
                 user-specified conditions associated with program
                 source code; it must be modularized in a fashion that
                 supports flexible composition with other tool
                 components, including integration with a variety of
                 testing and analysis techniques; and its performance
                 and capacity must be sufficient for analysis of real
                 application programs. Meeting these objectives together
                 is significantly more difficult than meeting any of
                 them alone. We describe the design and rationale of
                 Cats and report experience with an implementation. The
                 issues addressed here are primarily practical concerns
                 for modularizing and integrating tools for analysis of
                 actual source programs. We also report successful
                 application of Cats to major subsystems of a (nontoy)
                 highly concurrent user interface system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Ada; concurrency; software development environments;
                 static analysis; tool integration",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Software Engineering
                 --- Testing and Debugging (D.2.5); Software ---
                 Software Engineering --- Programming Environments
                 (D.2.6); Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Concurrent,
                 distributed, and parallel languages}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Concurrent programming
                 structures}",
}

@Article{Jackson:1995:ADB,
  author =       "Daniel Jackson",
  title =        "Aspect: detecting bugs with abstract dependences",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "2",
  pages =        "109--145",
  month =        apr,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-2/p109-jackson/p109-jackson.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-2/p109-jackson/",
  abstract =     "Aspect is a static analysis technique for detecting
                 bugs in imperative programs, consisting of an
                 annotation language and a checking tool. Like a type
                 declaration, an Aspect annotation of a procedure is a
                 kind of declarative, partial specification that can be
                 checked efficiently in a modular fashion. But instead
                 of constraining the types of arguments and results,
                 Aspect specifications assert dependences that should
                 hold between inputs and outputs. The checker uses a
                 simple dependence analysis to check code against
                 annotations and can find bugs automatically that are
                 not detectable by other static means, especially errors
                 of omission, which are common, but resistant to type
                 checking. This article explains the basic scheme and
                 shows how it is elaborated to handle data abstraction
                 and aliasing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Documentation; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "dataflow dependences; partial specification; partial
                 verification",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Assertion checkers};
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Symbolic execution}; Software
                 --- Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Abstract data types}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Assertions}; Theory of Computation ---
                 Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1): {\bf
                 Mechanical verification}; Theory of Computation ---
                 Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1): {\bf
                 Pre- and post-conditions}",
}

@Article{Zaremski:1995:SMT,
  author =       "Amy Moormann Zaremski and Jeannette M. Wing",
  title =        "Signature matching: a tool for using software
                 libraries",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "2",
  pages =        "146--170",
  month =        apr,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-2/p146-zaremski/p146-zaremski.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-2/p146-zaremski/",
  abstract =     "{\em Signature matching\/} is a method for organizing,
                 navigating through, and retrieving from software
                 libraries. We consider two kinds of software library
                 components--functions and modules--and hence two kinds
                 of matching--function matching and module matching. The
                 signature of a function is simply its type; the
                 signature of a module is a multiset of user-defined
                 types and a multiset of function signatures. For both
                 functions and modules, we consider not just {\em
                 exact\/} match but also various flavors of {\em
                 relaxed\/} match. We describe various applications of
                 signature matching as a tool for using software
                 libraries, inspired by the use of our implementation of
                 a function signature matcher written in Standard ML.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "signature matching; software retrieval",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering --- Miscellaneous
                 (D.2.m): {\bf Reusable software**}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Data types and structures};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Software libraries}",
}

@Article{Pezze:1995:GMR,
  author =       "Mauro Pezz{\`e} and Richard N. Taylor and Michal
                 Young",
  title =        "Graph models for reachability analysis of concurrent
                 programs",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "2",
  pages =        "171--213",
  month =        apr,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-2/p171-pezze/p171-pezze.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-2/p171-pezze/",
  abstract =     "The problem of analyzing concurrent systems has been
                 investigated by many researchers, and several solutions
                 have been proposed. Among the proposed techniques,
                 reachability analysis--systematic enumeration of
                 reachable states in a finite-state model--is attractive
                 because it is conceptually simple and relatively
                 straightforward to automate and can be used in
                 conjunction with model-checking procedures to check for
                 application-specific as well as general properties.
                 This article shows that the nature of the translation
                 from source code to a modeling formalism is of greater
                 practical importance than the underlying formalism.
                 Features identified as pragmatically important are the
                 representation of internal choice, selection of a
                 dynamic or static matching rule, and the ease of
                 applying reductions. Since combinatorial explosion is
                 the primary impediment to application of reachability
                 analysis, a particular concern in choosing a model is
                 facilitating divide-and-conquer analysis of large
                 programs. Recently, much interest in finite-state
                 verification systems has centered on algebraic theories
                 of concurrency. Algebraic structure can be used to
                 decompose reachability analysis based on a flowgraph
                 model. The semantic equivalence of graph and Petri
                 net-based models suggests that one ought to be able to
                 apply a similar strategy for decomposing Petri nets. We
                 describe how category-theoretic treatments of Petri
                 nets provide a basis for decomposition of Petri net
                 reachability analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Ada tasking; process algebra; static analysis",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3); Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf Petri
                 nets}; Software --- Software Engineering --- Testing
                 and Debugging (D.2.5): {\bf Debugging aids}; Software
                 --- Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Concurrent programming
                 structures}; Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1): {\bf Mechanical
                 verification}",
}

@Article{Brett:1995:CCS,
  author =       "Bevin R. Brett",
  title =        "Comments on {``The cost of selective recompilation and
                 environment processing''}",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "2",
  pages =        "214--216",
  month =        apr,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See \cite{Adams:1994:CSR,Tichy:1995:AR}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-2/p214-brett/p214-brett.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-2/p214-brett/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Software
                 Engineering --- Programming Environments (D.2.6);
                 Software --- Software Engineering --- Management
                 (D.2.9): {\bf Software configuration management};
                 Software --- Programming Languages --- Processors
                 (D.3.4)",
}

@Article{Tichy:1995:AR,
  author =       "Walter Tichy and Rolf Adams and Annette Weinert",
  title =        "Authors' response",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "2",
  pages =        "217--219",
  month =        apr,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See \cite{Adams:1994:CSR,Brett:1995:CCS}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-2/p217-tichy/p217-tichy.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-2/p217-tichy/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Software
                 Engineering --- Programming Environments (D.2.6);
                 Software --- Software Engineering --- Management
                 (D.2.9): {\bf Software configuration management};
                 Software --- Programming Languages --- Processors
                 (D.3.4)",
}

@Article{Sutton:1995:ALS,
  author =       "Stanley M. Sutton and Dennis Heimbigner and Leon J.
                 Osterweil",
  title =        "{APPL/A}: a language for software process
                 programming",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "3",
  pages =        "221--286",
  month =        jul,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-3/p221-sutton/p221-sutton.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-3/p221-sutton/",
  abstract =     "Software process programming is the coding of software
                 processes in executable programming languages. Process
                 programming offers many potential benefits, but their
                 realization has been hampered by a lack of experience
                 in the design and use of process programming languages.
                 APPL/A is a prototype software process programming
                 language developed to help gain this experience. It is
                 intended for the coding of programs to represent and
                 support software processes including process, product,
                 and project management. APPL/A is defined as an
                 extension to Ada, to which it adds persistent
                 programmable relations, concurrent triggers on relation
                 operations (for reactive control), optionally and
                 dynamically enforceable predicates on relations (which
                 may serve as constraints), and composite statements
                 that provide alternative combinations of
                 serializability, atomicity, and consistency enforcement
                 (for programming high-level transactions). APPL/A has
                 been used to code engineering-oriented applications,
                 like requirements specification and design, as well as
                 management-related activities, such as personnel
                 assignment, task scheduling, and project monitoring.
                 APPL/A has also enabled us to experiment with process
                 program design techniques and architectures, including
                 process state reification, intermittent (or persistent)
                 processes, reflexive and metaprocesses, and
                 multiple-process systems. Our ability to address a wide
                 range of software processes and process characteristics
                 indicates that the APPL/A constructs represent
                 important and general capabilities for software process
                 programming. \par

                 -- {\em Authors' Abstract\/}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "consistency management; multiparadigm programming
                 languages; software process programming; transaction
                 management",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Programming Languages
                 --- Language Classifications (D.3.2): {\bf Ada};
                 Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf APPL}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3); Information Systems --- Database
                 Management --- Languages (H.2.3): {\bf Database
                 (persistent) programming languages}",
}

@Article{Callison:1995:TSO,
  author =       "H. Rebecca Callison",
  title =        "A time-sensitive object model for real-time systems",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "3",
  pages =        "287--317",
  month =        jul,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-3/p287-callison/p287-callison.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-3/p287-callison/",
  abstract =     "Process-oriented models for real-time systems focus on
                 the timing constraints of {\em processes}, a focus that
                 can adversely affect resulting designs. Data
                 dependencies between processes create scheduling
                 interactions that limit the times at which processes
                 may execute. Processes are then designed to fit
                 available windows in the overall system schedule.
                 ``Fitting in'' frequently involves fragmenting
                 processes to fit scheduling windows and/or designing
                 program and data structures for speed rather than for
                 program comprehension. The result is often a system
                 with very sensitive timing that is hard to understand
                 and maintain. As an alternative to process-oriented
                 design, we present time-sensitive objects: a
                 data-oriented model for real-time systems. The
                 time-sensitive object (TSO) model structures systems as
                 time-constrained data, rather than time constrained
                 processing. Object values are extended to object
                 histories in which a sequence of time constrained
                 values describe the evolution of the object over time.
                 Systems comprise a set of objects and their
                 dependencies. The TSO model describes the effects of
                 object operations and the propagation of change among
                 related objects. Periodic objects, a class of objects
                 within the TSO model, are described in detail in this
                 article and compared with traditional periodic
                 processes. Advantages of time-sensitive objects are
                 identified, including greater scheduling independence
                 when processes have data dependencies, more opportunity
                 for concurrency, and greater inherent capability for
                 detection of and tolerance to timing errors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concurrency; fault tolerance; object models;
                 programming techniques; real-time processing models;
                 timing constraints",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3); Software --- Software Engineering
                 --- Design** (D.2.10); Software --- Operating Systems
                 --- Reliability (D.4.5): {\bf Fault-tolerance};
                 Software --- Operating Systems --- Organization and
                 Design (D.4.7): {\bf Real-time systems and embedded
                 systems}",
}

@Article{Abowd:1995:FSU,
  author =       "Gregory D. Abowd and Robert Allen and David Garlan",
  title =        "Formalizing style to understand descriptions of
                 software architecture",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "4",
  pages =        "319--364",
  month =        oct,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-4/p319-abowd/p319-abowd.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-4/p319-abowd/",
  abstract =     "The software architecture of most systems is usually
                 described informally and diagrammatically by means of
                 boxes and lines. In order for these descriptions to be
                 meaningful, the diagrams are understood by interpreting
                 the boxes and lines in specific, conventionalized ways.
                 The informal, imprecise nature of these interpretations
                 has a number of limitations. In this article we
                 consider these conventionalized interpretations as
                 architectural styles and provide a formal framework for
                 their uniform definition. In addition to providing a
                 template for precisely defining new architectural
                 styles, this framework allows for analysis within and
                 between different architectural styles.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "software architecture; Z notation",
  subject =      "Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Specification techniques};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Z}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Semantics of Programming Languages (F.3.2): {\bf
                 Denotational semantics}; Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2);
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Languages}; Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2):
                 {\bf Modules and interfaces}",
}

@Article{Jackson:1995:SZS,
  author =       "Daniel Jackson",
  title =        "Structuring {Z} specifications with views",
  journal =      j-TOSEM,
  volume =       "4",
  number =       "4",
  pages =        "365--389",
  month =        oct,
  year =         "1995",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1995-4-4/p365-jackson/p365-jackson.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1995-4-4/p365-jackson/",
  abstract =     "A view is a partial specification of a program,
                 consisting of a state space and a set of operations. A
                 full specification is obtained by composing several
                 views, linking them through their states (by asserting
                 invariants across views) and through their operations
                 (by defining external operations as combinations of
                 operations from different views). By encouraging
                 multiple representations of the program's state, view
                 structuring lends clarity and terseness to the
                 specification of operations. And by separating
                 different aspects of functionality, it brings
                 modularity at the grossest level of organization, so
                 that specifications can accommodate change more
                 gracefully. View structuring in Z is demonstrated with
                 a few small examples. Both the features of Z that lend
                 themselves to view structuring and those that are a
                 hindrance are discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal specification; implicit definition; views; Z",
  subject =      "Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Specification techniques};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Design** (D.2.10): {\bf
                 Representation**}; Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf Modules
                 and interfaces}; Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Z}",
}

@Article{vandenBrand:1996:GFC,
  author =       "Mark van den Brand and Eelco Visser",
  title =        "Generation of formatters for context-free languages",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "1",
  pages =        "1--41",
  month =        jan,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 31 06:33:29 2003",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-1/p1-van\_den\_brand/p1-van\_den\_brand.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-1/p1-van\_den\_brand/;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-1/p1-van_den_brand/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Devanbu:1996:GTA,
  author =       "Premkumar T. Devanbu and David S. Rosenblum and
                 Alexander L. Wolf",
  title =        "Generating testing and analysis tools with {Aria}",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "1",
  pages =        "42--62",
  month =        jan,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-1/p42-devanbu/p42-devanbu.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-1/p42-devanbu/",
  abstract =     "Many software testing and analysis tools manipulate
                 graph representations of programs, such as abstract
                 syntax trees or abstract semantics graphs. Handcrafting
                 such tools in conventional programming languages can be
                 difficult, error prone, and time consuming. Our
                 approach is to use application generators targeted for
                 the domain of graph-representation-based testing and
                 analysis tools. Moreover, we generate the generators
                 themselves, so that the development of tools based on
                 different languages and/or representations can also be
                 supported better. In this article we report on our
                 experiences in developing and using a system called
                 Aria that generates testing and analysis tools based on
                 an abstract semantics graph representation for C and
                 C++ called Reprise. Aria itself was generated by the
                 Genoa system. We demonstrate the utility of Aria and,
                 thereby, the power of our approach, by showing Aria's
                 use in the development of a number of useful testing
                 and analysis tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Design; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "application generators; Aria; Genoa; program
                 dependence graphs; program representations; Reprise;
                 software analysis; software testing; tools",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Software libraries}; Software
                 --- Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Control structures}; Software
                 --- Programming Languages --- Processors (D.3.4): {\bf
                 Code generation}; Data --- Data Structures (E.1): {\bf
                 Graphs and networks}; Software --- Programming
                 Languages --- Language Constructs and Features (D.3.3):
                 {\bf Data types and structures}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Parsing}; Software --- Software Engineering --- Metrics
                 (D.2.8): {\bf Complexity measures}; Software ---
                 Software Engineering --- Testing and Debugging
                 (D.2.5)",
}

@Article{Ferguson:1996:CAS,
  author =       "Roger Ferguson and Bogdan Korel",
  title =        "The chaining approach for software test data
                 generation",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "1",
  pages =        "63--86",
  month =        jan,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-1/p63-ferguson/p63-ferguson.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-1/p63-ferguson/",
  abstract =     "Software testing is very labor intensive and expensive
                 and accounts for a significant portion of software
                 system development cost. If the testing process could
                 be automated, the cost of developing software could be
                 significantly reduced. Test data generation in program
                 testing is the process of identifying a set of test
                 data that satisfies a selected testing criterion, such
                 as statement coverage and branch coverage. In this
                 article we present a {\em chaining approach\/} for
                 automated software test data generation which builds on
                 the current theory of execution-oriented test data
                 generation. In the chaining approach, test data are
                 derived based on the actual execution of the program
                 under test. For many programs, the execution of the
                 selected statement may require prior execution of some
                 other statements. The existing methods of test data
                 generation may not efficiently generate test data for
                 these types of programs because they only use control
                 flow information of a program during the search
                 process. The chaining approach uses data dependence
                 analysis to guide the search process, i.e., data
                 dependence analysis automatically identifies statements
                 that affect the execution of the selected statement.
                 The chaining approach uses these statements to form a
                 sequence of statements that is to be executed prior to
                 the execution of the selected statement. The
                 experiments have shown that the chaining approach may
                 significantly improve the chances of finding test data
                 as compared to the existing methods of automated test
                 data generation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Measurement; Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "data dependency; dynamic analysis; heuristics; program
                 execution",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}",
}

@Article{Weyuker:1996:UFC,
  author =       "Elaine J. Weyuker",
  title =        "Using failure cost information for testing and
                 reliability assessment",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "2",
  pages =        "87--98",
  month =        apr,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-2/p87-weyuker/p87-weyuker.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-2/p87-weyuker/",
  abstract =     "A technique for incorporating failure cost information
                 into algorithms designed to automatically generate
                 software-load-testing suites is presented. A previously
                 introduced reliability measure is also modified to
                 incorporate this cost information. examples are
                 presented to show the usefulness of including cost
                 information when testing or assessing software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Measurement; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "failure cost; software testing; test case selection",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Software --- Software Engineering
                 --- General (D.2.0)",
}

@Article{Offutt:1996:EDS,
  author =       "A. Jefferson Offutt and Ammei Lee and Gregg Rothermel
                 and Roland H. Untch and Christian Zapf",
  title =        "An experimental determination of sufficient mutant
                 operators",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "2",
  pages =        "99--118",
  month =        apr,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-2/p99-offutt/p99-offutt.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-2/p99-offutt/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Measurement; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5)",
}

@Article{Bergadano:1996:TMI,
  author =       "Francesco Bergadano and Daniele Gunetti",
  title =        "Testing by means of inductive program learning",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "2",
  pages =        "119--145",
  month =        apr,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-2/p119-bergadano/p119-bergadano.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-2/p119-bergadano/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "program induction by examples",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Computing Methodologies ---
                 Artificial Intelligence --- Learning (I.2.6)",
}

@Article{Snelting:1996:RCB,
  author =       "Gregor Snelting",
  title =        "Reengineering of configurations based on mathematical
                 concept analysis",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "2",
  pages =        "146--189",
  month =        apr,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-2/p146-snelting/p146-snelting.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-2/p146-snelting/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concept analysis; concept lattices",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6): {\bf Interactive environments};
                 Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7); Software ---
                 Software Engineering --- Management (D.2.9): {\bf
                 Software configuration management}",
}

@Article{Cugola:1996:FFI,
  author =       "Gianpaolo Cugola and Elisabetta {Di Nitto} and Alfonso
                 Fuggetta and Carlo Ghezzi",
  title =        "A framework for formalizing inconsistencies and
                 deviations in human-centered systems",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "3",
  pages =        "191--230",
  month =        jul,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-3/p191-cugola/p191-cugola.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-3/p191-cugola/",
  abstract =     "Most modern business activities are carried out by a
                 combination of computerized tools and human agents.
                 Typical examples are engineering design activities,
                 office procedures, and banking systems. All these {\em
                 human-centered systems\/} are characterized by the
                 interaction among people, and between people and
                 computerized tools. This interaction defines a process,
                 whose effectiveness is essential to ensure the quality
                 of the delivered products and/or services. To support
                 these systems, process-centered environments and
                 workflow management systems have been recently
                 developed. They can be collectively identified with the
                 term {\em process technology}. This technology is based
                 on the explicit definition of the process to be
                 followed (the {\em process model\/} ). The model
                 specifies the kind of support that has to be provided
                 to human agents. An essential property that process
                 technology mut exhibit is the ability of tolerating,
                 controlling, and supporting {\em deviations\/} and {\em
                 inconsistencies\/} of the real-world behaviors with
                 respect to the process model. This is necessary to
                 provide consistent and effective support to the
                 human-centered system, still maintaining a high degree
                 of flexibility and adaptability to the evolving needs,
                 preferences, an expertise of the human agents. This
                 article presents a formal framework to characterize the
                 interaction between a human-centered system and its
                 automated support. It does not aim at introducing a new
                 language or system to describe processes. Rather, it
                 aims at identifying the basic properties and features
                 that make it possible to formally define the concepts
                 of inconsistency and deviation. This formal framework
                 can then be used to compare existing solutions and
                 guide future research work.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Human Factors; Management; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "business processes; deviation; formal model;
                 human-centered systems; inconsistency; software
                 processes",
  subject =      "Information Systems --- Models and Principles ---
                 User/Machine Systems (H.1.2); Software --- Software
                 Engineering --- Programming Environments (D.2.6);
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3)",
}

@Article{Heitmeyer:1996:ACC,
  author =       "Constance L. Heitmeyer and Ralph D. Jeffords and Bruce
                 G. Labaw",
  title =        "Automated consistency checking of requirements
                 specifications",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "3",
  pages =        "231--261",
  month =        jul,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-3/p231-heitmeyer/p231-heitmeyer.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-3/p231-heitmeyer/",
  abstract =     "This article describes a formal analysis technique,
                 called {\em consistency checking}, for automatic
                 detection of errors, such as type errors,
                 nondeterminism, missing cases, and circular
                 definitions, in requirements specifications. The
                 technique is designed to analyze requirements
                 specifications expressed in the SCR (Software Cost
                 Reduction) tabular notation. As background, the SCR
                 approach to specifying requirements is reviewed. To
                 provide a formal semantics for the SCR notation and a
                 foundation for consistency checking, a formal
                 requirements model is introduced; the model represents
                 a software system as a finite-state automation which
                 produces externally visible outputs in response to
                 changes in monitored environmental quantities. Results
                 of two experiments are presented which evaluated the
                 utility and scalability of our technique for
                 consistency checking in real-world avionics
                 application. The role of consistency checking during
                 the requirements phase of software development is
                 discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Management; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "application-independent properties; consistency
                 checking; formal requirements modeling; software cost
                 reduction methodology; tabular notations",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4); Software --- Software Engineering
                 --- Requirements/Specifications (D.2.1); Computing
                 Milieux --- Management of Computing and Information
                 Systems --- Software Management (K.6.3); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2)",
}

@Article{Murphy:1996:LLS,
  author =       "Gail C. Murphy and David Notkin",
  title =        "Lightweight lexical source model extraction",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "3",
  pages =        "262--292",
  month =        jul,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-3/p262-murphy/p262-murphy.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-3/p262-murphy/",
  abstract =     "Software engineers maintaining an existing software
                 system often depend on the mechanized extraction of
                 information from system artifacts. Some useful kinds of
                 information--source models--are well known: call
                 graphs, file dependences, etc. Predicting every kind of
                 source model that a software engineer may need is
                 impossible. We have developed a lightweight approach
                 for generating flexible and tolerant source model
                 extractors from lexical specifications. The approach is
                 lightweight in that the specifications are relatively
                 small and easy to write. It is flexible in that there
                 are few constraints on the kinds of artifacts from
                 which source models are extracted (e.g., we can extract
                 from source code, structured data files, documentation,
                 etc.). It is tolerant in that there are few constraints
                 on the condition of the artifacts. For example, we can
                 extract from source that cannot necessarily be
                 compiled. Our approach extended the kinds of source
                 models that can be easily produced from lexical
                 information while avoiding the constraints and
                 brittleness of most parser-based approaches. We have
                 developed tools to support this approach and applied
                 the tools to the extraction of a number of different
                 source models (file dependences, event interactions,
                 call graphs) from a variety of system artifacts (C,
                 C++, CLOS, Eiffel. TCL, structured data). We discuss
                 our approach and describe its application to extract
                 source models not available using existing systems; for
                 example, we compute the implicitly-invokes relation
                 over Field tools. We compare and contrast our approach
                 to the conventional lexical and syntactic approaches of
                 generating source models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Experimentation; Languages; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "lexical analysis; lexing; reverse engineering; scanner
                 generation; scanning; software maintenance; source code
                 analysis; source model; static analysis",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Programming Languages
                 --- Processors (D.3.4); Software --- Software
                 Engineering --- General (D.2.0)",
}

@Article{Harel:1996:SSS,
  author =       "David Harel and Amnon Naamad",
  title =        "The {STATEMATE} semantics of statecharts",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "4",
  pages =        "293--333",
  month =        oct,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-4/p293-harel/p293-harel.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-4/p293-harel/",
  abstract =     "We describe the semantics of statecharts as
                 implemented in the STATEMATE system. This was the first
                 executable semantics defined for the language and has
                 been in use for almost a decade. In terms of the
                 controversy around whether changes made in a given step
                 should take effect in the current step or in the next
                 one, this semantics adopts the latter approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "behavioral modeling; reactive system; semantics;
                 statechart; STATEMATE",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Programming Languages
                 --- Formal Definitions and Theory (D.3.1): {\bf
                 Semantics}; Theory of Computation --- Logics and
                 Meanings of Programs --- Semantics of Programming
                 Languages (F.3.2)",
}

@Article{Cheung:1996:CCC,
  author =       "Shing Chi Cheung and Jeff Kramer",
  title =        "Context constraints for compositional reachability
                 analysis",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "4",
  pages =        "334--377",
  month =        oct,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-4/p334-cheung/p334-cheung.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-4/p334-cheung/",
  abstract =     "Behavior analysis of complex distributed systems has
                 led to the search for enhanced reachability analysis
                 techniques which support modularity and which control
                 the state explosion problem. While modularity has been
                 achieved, state explosion in still a problem. Indeed,
                 this problem may even be exacerbated, as a locally
                 minimized subsystem may contain many states and
                 transitions forbidden by its environment or context.
                 Context constraints, specified as interface processes,
                 are restrictions imposed by the environment on
                 subsystem behavior. Recent research has suggested that
                 the state explosion problem can be effectively
                 controlled if context constraints are incorporated in
                 compositional reachability analysis (CRA). Although
                 theoretically very promising, the approach has rarely
                 been used in practice because it generally requires a
                 more complex computational model and does not contain a
                 mechanism to derive context constraints automatically.
                 This article presents a technique to automate the
                 approach while using a similar computational model to
                 that of CRA. Context constraints are derived
                 automatically, based on a set of sufficient conditions
                 for these constraints to be transparently included when
                 building reachability graphs. As a result, the global
                 reachability graph generated using the derived
                 constraints is shown to be observationally equivalent
                 to that generated by CRA without the inclusion of
                 context constraints. Constraints can also be specified
                 explicitly by users, based on their application
                 knowledge. Erroneous constraints which contravene
                 transparency can be identified together with an
                 indication of the error sources. User-specified
                 constraints can be combined with those generated
                 automatically. The technique is illustrated using a
                 clients/server system and other examples.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Reliability; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "compositional techniques; concurrency; context
                 constraints; distributed systems; labeled transition
                 systems; reachability analysis; state space reduction;
                 static analysis; validation",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Concurrent,
                 distributed, and parallel languages}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Concurrent programming
                 structures}; Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1)",
}

@Article{Barrett:1996:FEB,
  author =       "Daniel J. Barrett and Lori A. Clarke and Peri L. Tarr
                 and Alexander E. Wise",
  title =        "A framework for event-based software integration",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "4",
  pages =        "378--421",
  month =        oct,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-4/p378-barrett/p378-barrett.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-4/p378-barrett/",
  abstract =     "Although event-based software integration is one of
                 the most prevalent approaches to loose integration, no
                 consistent model for describing it exists. As a result,
                 there is no uniform way to discuss event-based
                 integration, compare approaches and implementations,
                 specify new event-based approaches, or match user
                 requirements with the capabilities of event-based
                 integration systems. We attempt to address these
                 shortcomings by specifying a {\em generic framework for
                 event-based integration}, the EBI framework, that
                 provides a flexible, object-oriented model for
                 discussing and comparing event-based integration
                 approaches. The EBI framework can model dynamic and
                 static specification, composition, and decomposition
                 and can be instantiated to describe the features of
                 most common event-based integration approaches. We
                 demonstrate how to use the framework as a reference
                 model by comparing and contrasting three well-known
                 integration systems: FIELD, Polylith, and CORBA.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "control integration; CORBA; event-based systems;
                 FIELD; interoperability; Polylith; reference model;
                 software integration",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2)",
}

@Article{Anonymous:1996:AI,
  author =       "Anonymous",
  title =        "Author Index",
  journal =      j-TOSEM,
  volume =       "5",
  number =       "4",
  pages =        "422--423",
  month =        oct,
  year =         "1996",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:05:47 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1996-5-4/p422-authorindex/p422-authorindex.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-4/p422-author\_index/;
                 http://www.acm.org/pubs/citations/journals/tosem/1996-5-4/p422-author_index/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zave:1997:FDC,
  author =       "Pamela Zave and Michael Jackson",
  title =        "Four dark corners of requirements engineering",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "1",
  pages =        "1--30",
  month =        jan,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-1/p1-zave/p1-zave.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-1/p1-zave/",
  abstract =     "Research in requirements engineering has produced an
                 extensive body of knowledge, but there are four areas
                 in which the foundation of the discipline seems weak or
                 obscure. This article shines some light in the ``four
                 dark corners,'' exposing problems and proposing
                 solutions. We show that all descriptions involved in
                 requirements engineering should be descriptions of the
                 environment. We show that certain control information
                 is necessary for sound requirements engineering, and we
                 explain the close association between domain knowledge
                 and refinement of requirements. Together these
                 conclusions explain the precise nature of requirements,
                 specifications, and domain knowledge, as well as the
                 precise nature of the relationships among them. They
                 establish minimum standards for what information should
                 be represented in a requirements language. They also
                 make it possible to determine exactly what it means for
                 requirements and engineering to be successfully
                 completed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "control of actions; domain knowledge; implementation
                 bias; refinement of requirements",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}",
}

@Article{Moser:1997:GED,
  author =       "L. E. Moser and Y. S. Ramakrishna and G. Kutty and P.
                 M. Melliar-Smith and L. K. Dillon",
  title =        "A graphical environment for the design of concurrent
                 real-time systems",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "1",
  pages =        "31--79",
  month =        jan,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-1/p31-moser/p31-moser.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-1/p31-moser/",
  abstract =     "Concurrent real-time systems are among the most
                 difficult systems to design because of the many
                 possible interleavings of events and because of the
                 timing requirements that must be satisfied. We have
                 developed a graphical environment based on Real-Time
                 Graphical Interval Logic (RTGIL) for specifying and
                 reasoning about the designs of concurrent real-time
                 systems. Specifications in the logic have an intuitive
                 graphical representation that resembles the timing
                 diagrams drawn by software and hardware engineers, with
                 real-time constraints that bound the durations of
                 intervals. The syntax-directed editor of the RTGIL
                 environment enables the user to compose and edit
                 graphical formulas on a workstation display; the
                 automated theorem prover mechanically checks the
                 validity of proofs in the logic; and the database and
                 proof manager tracks proof dependencies and allows
                 formulas to be stored and retrieved. This article
                 describes the logic, methodology, and tools that
                 comprise the prototype RTGIL environment and
                 illustrates the use of the environment with an example
                 application.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automated deduction; concurrent systems; formal
                 specification and verification; graphical user
                 interface; real-time systems; temporal logic",
  subject =      "Computer Systems Organization --- Special-Purpose and
                 Application-Based Systems (C.3): {\bf Real-time and
                 embedded systems}; Software --- Software Engineering
                 --- Requirements/Specifications (D.2.1): {\bf
                 Methodologies (e.g., object-oriented, structured)};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Tools};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Design** (D.2.10): {\bf Methodologies**}; Software
                 --- Software Engineering --- Design** (D.2.10): {\bf
                 Representation**}; Theory of Computation ---
                 Mathematical Logic and Formal Languages ---
                 Mathematical Logic (F.4.1): {\bf Mechanical theorem
                 proving}; Theory of Computation --- Mathematical Logic
                 and Formal Languages --- Formal Languages (F.4.3): {\bf
                 Decision problems}",
}

@Article{Dillon:1997:TDT,
  author =       "Laura K. Dillon",
  title =        "Task dependence and termination in {Ada}",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "1",
  pages =        "80--110",
  month =        jan,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-1/p80-dillon/p80-dillon.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-1/p80-dillon/",
  abstract =     "This article analyzes the semantics of task dependence
                 and termination in Ada. We use a contour model of Ada
                 tasking in examining the implications of and possible
                 motivation for the rules that determine when procedures
                 and tasks terminate during execution of an Ada program.
                 The termination rules prevent the data that belong to
                 run-time instances of scope units from being
                 deallocated prematurely, but they are unnecessarily
                 conservative in this regard. For task instances that
                 are created by invoking a storage allocator, we show
                 that the conservative termination policy allows heap
                 storage to be managed more efficiently than a less
                 conservative policy. The article also examines the
                 manner in which the termination rules affect the
                 synchronization of concurrent tasks. Master-slave and
                 client-server applications are considered. We show that
                 the rules for distributed termination of concurrent
                 tasks guarantee that a task terminates only if it can
                 no longer affect the outcome of an execution. The
                 article is meant to give programmers a better
                 understanding of Ada tasking and to help language
                 designers assess the strengths and weaknesses of the
                 termination model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Ada tasking; distributed termination; master/dependent
                 relation; task termination; tasking execution model",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Concurrent
                 programming structures}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Ada}",
}

@Article{Henninger:1997:EAC,
  author =       "Scott Henninger",
  title =        "An evolutionary approach to constructing effective
                 software reuse repositories",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "2",
  pages =        "111--140",
  month =        apr,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-2/p111-henninger/p111-henninger.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-2/p111-henninger/",
  abstract =     "Repositories for software reuse are faced with two
                 interrelated problems: (1) acquiring the knowledge to
                 initially construct the repository and (2) modifying
                 the repository to meet the evolving and dynamic needs
                 of software development organizations. Current software
                 repository methods rely heavily on classification,
                 which exacerbates acquisition and evolution problems by
                 requiring costly classification and domain analysis
                 efforts before a repository can be used effectively,
                 This article outlines an approach that avoids these
                 problems by choosing a retrieval method that utilizes
                 minimal repository structure to effectively support the
                 process of finding software components. The approach is
                 demonstrated through a pair of proof-of-concept
                 prototypes: PEEL, a tool to semiautomatically identify
                 reusable components, and CodeFinder, a retrieval system
                 that compensates for the lack of explicit knowledge
                 structures through a spreading activation retrieval
                 process. CodeFinder also allows component
                 representations to be modified while users are
                 searching for information. This mechanism adapts to the
                 changing nature of the information in the repository
                 and incrementally improves the repository while people
                 use it. The combination of these techniques holds
                 potential for designing software repositories that
                 minimize up-front costs, effectively support the search
                 process, and evolve with an organization's changing
                 needs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "component repositories; information retrieval;
                 software reuse",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Software libraries}; Software
                 --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf User interfaces}; Information
                 Systems --- Information Storage and Retrieval ---
                 Information Search and Retrieval (H.3.3): {\bf Query
                 formulation}; Information Systems --- Information
                 Storage and Retrieval --- Information Search and
                 Retrieval (H.3.3): {\bf Retrieval models}",
}

@Article{Devanbu:1997:UDL,
  author =       "Premkumar Devanbu and Mark A. Jones",
  title =        "The use of description logics in {KBSE} systems",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "2",
  pages =        "141--172",
  month =        apr,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-2/p141-devalbu/p141-devalbu.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-2/p141-devanbu/",
  abstract =     "The increasing size and complexity of many software
                 systems demand a greater emphasis on capturing and
                 maintaining knowledge at many different levels within
                 the software development process. This knowledge
                 includes descriptions of the hardware and software
                 components and their behavior, external and internal
                 design specifications, and support for system testing.
                 The Knowledge-based software engineering (KBSE)
                 research paradigm is concerned with systems that use
                 formally represented knowledge, with associated
                 inference procedures, to support the various
                 subactivities of software development. As they growing
                 scale, KBSE systems must balance expressivity and
                 inferential power with the real demands of knowledge
                 base construction, maintenance, performance, and
                 comprehensibility. {\em Description logics\/} (DLs)
                 possess several features--a terminological orientation,
                 a formal semantics, and efficient reasoning
                 procedures--which offer an effective tradeoff of these
                 factors. We discuss three KBSE systems in which DLs
                 capture some of the requisite knowledge needed to
                 support design, coding, and testing activities. We then
                 survey some alternative approaches (to DLs) in KBSE
                 systems. We close with a discussion of the benefits of
                 DLs and ways to address some of their limitations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automated software engineering; knowledge basis;
                 logics; software development environments; testing;
                 tools",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2); Software --- Software Engineering
                 --- Coding Tools and Techniques (D.2.3); Software ---
                 Software Engineering --- Testing and Debugging (D.2.5);
                 Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Methodologies ---
                 Artificial Intelligence --- Automatic Programming
                 (I.2.2); Computing Methodologies --- Artificial
                 Intelligence --- Knowledge Representation Formalisms
                 and Methods (I.2.4): {\bf Representations (procedural
                 and rule-based)}",
}

@Article{Rothermel:1997:SER,
  author =       "Gregg Rothermel and Mary Jean Harrold",
  title =        "A safe, efficient regression test selection
                 technique",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "2",
  pages =        "173--210",
  month =        apr,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-2/p173-rothermel/p173-rothermel.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-2/p173-rothermel/",
  abstract =     "Regression testing is an expensive but necessary
                 maintenance activity performed on modified software to
                 provide confidence that changes are correct and do not
                 adversely affect other portions of the software. A
                 regression test selection technique chooses, from an
                 existing test set, tests that are deemed necessary to
                 validate modified software. We present a new technique
                 for regression test selection. Our algorithms construct
                 control flow graphs for a procedure or program and its
                 modified version and use these graphs to select tests
                 that execute changed code from the original test suite.
                 We prove that, under certain conditions, the set of
                 tests our technique selects includes every test from
                 the original test suite that con expose faults in the
                 modified procedure or program. Under these conditions
                 our algorithms are {\em safe}. Moreover, although our
                 algorithms may select some tests that cannot expose
                 faults, they are at lease as precise as other safe
                 regression test selection algorithms. Unlike many other
                 regression test selection algorithms, our algorithms
                 handle all language constructs and all types of program
                 modifications. We have implemented our algorithms;
                 initial empirical studies indicate that our technique
                 can significantly reduce the cost of regression testing
                 modified software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Measurement; Performance; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "regression test selection; regression testing;
                 selective retest",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Testing and Debugging (D.2.5); Software ---
                 Software Engineering --- Distribution, Maintenance, and
                 Enhancement (D.2.7): {\bf Corrections**}",
}

@Article{Allen:1997:FBA,
  author =       "Robert Allen and David Garlan",
  title =        "A formal basis for architectural connection",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "3",
  pages =        "213--249",
  month =        jul,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See errata \cite{Allen:1998:EFB}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-3/p213-allen/p213-allen.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-3/p213-allen/",
  abstract =     "As software systems become more complex, the overall
                 system structure--or software architecture--becomes a
                 central design problem. An important step toward an
                 engineering discipline of software is a formal basis
                 for describing and analyzing these designs. In the
                 article we present a formal approach to one aspect of
                 architectural design: the interactions among
                 components. The key idea is to define architectural
                 connectors as explicit semantic entities. These are
                 specified as a collection of protocols that
                 characterize each of the participant roles in an
                 interaction and how these roles interact. We illustrate
                 how this scheme can be used to define a variety of
                 common architectural connectors. We further provide a
                 formal semantics and show how this leads to a system in
                 which architectural compatibility can be checked in a
                 way analogous to type-checking in programming
                 languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal models; model-checking; module interconnection;
                 software analysis; WRIGHT",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering --- Design**
                 (D.2.10): {\bf Representation**}; Theory of Computation
                 --- Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1): {\bf
                 Specification techniques}; Theory of Computation ---
                 Mathematical Logic and Formal Languages --- Formal
                 Languages (F.4.3)",
}

@Article{Roman:1997:MUR,
  author =       "Gruia-Catalin Roman and Peter J. McCann and Jerome Y.
                 Plun",
  title =        "Mobile {UNITY}: reasoning and specification in mobile
                 computing",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "3",
  pages =        "250--282",
  month =        jul,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-3/p250-roman/p250-roman.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-3/p250-roman/",
  abstract =     "Mobile computing represents a major point of departure
                 from the traditional distributed-computing paradigm.
                 The potentially very large number of independent
                 computing units, a decoupled computing style, frequent
                 disconnections, continuous position changes, and the
                 location-dependent nature of the behavior and
                 communication patterns present designers with
                 unprecedented challenges in the areas of modularity and
                 dependability. So far, the literature on mobile
                 computing is dominated by concerns having to de with
                 the development of protocols and services. This article
                 complements this perspective by considering the nature
                 of the underlying formal models that will enable us to
                 specify and reason about such computations. The basic
                 research goal is to characterize fundamental issues
                 facing mobile computing. We want to achieve this in a
                 manner analogous to the way concepts such as shared
                 variables and message passing help us understand
                 distributed computing. The pragmatic objective is to
                 develop techniques that facilitate the verification and
                 design of dependable mobile systems. Toward this goal
                 we employ the methods of UNITY. To focus on what is
                 essential, we center our study on {\em ad hoc
                 networks}, whose singular nature is bound to reveal the
                 ultimate impact of movement on the way one computes and
                 communicates in a mobile environment. To understand
                 interactions we start with the UNITY concepts of union
                 and superposition and consider direct generalizations
                 to transient interactions. The motivation behind the
                 transient nature of the interactions comes from the
                 fact that components can communicate with each other
                 only when they are within a certain range. The notation
                 we employ is a highly modular extension of the UNITY
                 programming notation. Reasoning about mobile
                 computations relies on extensions to the UNITY proof
                 logic.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Reliability; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal methods; mobile computing; mobile UNITY; shared
                 variables; synchronization; transient interactions;
                 weak consistency",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Correctness proofs};
                 Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Semantics};
                 Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Concurrent
                 programming structures}; Theory of Computation ---
                 Logics and Meanings of Programs --- Specifying and
                 Verifying and Reasoning about Programs (F.3.1); Theory
                 of Computation --- Logics and Meanings of Programs ---
                 Semantics of Programming Languages (F.3.2)",
}

@Article{Ambriola:1997:APC,
  author =       "Vincenzo Ambriola and Reidar Conradi and Alfonso
                 Fuggetta",
  title =        "Assessing process-centered software engineering
                 environments",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "3",
  pages =        "283--328",
  month =        jul,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-3/p283-ambriola/p283-ambriola.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-3/p283-ambriola/",
  abstract =     "Process-centered software engineering environments
                 (PSEEs) are the most recent generation of environments
                 supporting software development activities. They
                 exploit a representation of the process (called the
                 {\em process model\/}) that specifies how to carry out
                 software development activities, the roles and tasks of
                 software developers, and how to use and control
                 software development tools. A process model is
                 therefore a vehicle to better understand and
                 communicate the process. If it is expressed in a formal
                 notation, it can be used to support a variety of
                 activities such as process analysis, process
                 simulation, and process enactment. PSEEs provide
                 automatic support for these activities. They exploit
                 languages based on different paradigms, such as Petri
                 nets and rule-based systems. They include facilities to
                 edit and analyze process models. By enacting the
                 process model, a PSEE provides a variety of services,
                 such as assistance for software developers, automation
                 of routine tasks, invocation and control of software
                 development tools, and enforcement of mandatory rules
                 and practices. Several PSEEs have been developed, both
                 as research projects and as commercial products. The
                 initial deployment and exploitation of this technology
                 have made it possible to produce a significant amount
                 of experiences, comments, evaluations, and feedback. We
                 still lack, however, consistent and comprehensive
                 assessment methods that can be used to collect and
                 organize this information. This article aims at
                 contributing to the definition of such methods, by
                 providing a systematic comparison grid and by
                 accomplishing an initial evaluation of the state of the
                 art in the field. This evaluation takes into account
                 the systems that have been developed by the authors in
                 the past five years, as well as the main
                 characteristics of other well-known environments",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Human Factors; Languages; Management",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "CASE; enabling technology; process modeling languages;
                 process-centered software engineering environments;
                 software process",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Milieux --- Management
                 of Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software development};
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3):
                 {\bf Software maintenance}; Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2):
                 {\bf Computer-aided software engineering (CASE)}",
}

@Article{Petrenko:1997:CRT,
  author =       "Alexandre Petrenko",
  title =        "Comments on {``A reduced test suite for protocol
                 conformance testing''}",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "3",
  pages =        "329--331",
  month =        jul,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See \cite{Bernhard:1994:RTS}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-3/p329-petrenko/p329-petrenko.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-3/p329-petrenko/",
  abstract =     "A previous {\em ACM TOSEM\/} article of Ph. Bernhard
                 (``A Reduced Test Suite of Protocol Conformance
                 Testing,'' {\em ACM Transactions on Software
                 Engineering and Methodology}, Vol. 3, No. 3, July 1994,
                 pages 201--220) describes three new versions of the
                 so-called W-method for solving the protocol-testing
                 problem, i.e., solving the Mealy machine equivalence
                 problem. The author claims that these versions all have
                 the same fault detection capability as the original
                 W-method. In this correspondence we prove that the
                 results of that article are incorrect.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2): {\bf Protocol verification}; Software ---
                 Software Engineering --- Testing and Debugging (D.2.5):
                 {\bf Testing tools (e.g., data generators, coverage
                 testing)}",
}

@Article{Zaremski:1997:SMS,
  author =       "Amy Moormann Zaremski and Jeannette M. Wing",
  title =        "Specification matching of software components",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "4",
  pages =        "333--369",
  month =        oct,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-4/p333-zaremski/p333-zaremski.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-4/p333-zaremski/",
  abstract =     "Specification matching is a way to compare two
                 software components, based on descriptions of the
                 component's behaviors. In the context of software reuse
                 and library retrieval, it can help determine whether
                 one component can be substituted for another or how one
                 can be modified to fit the requirements of the other.
                 In the context of object-oriented programming, it can
                 help determine when one type is a behavioral subtype of
                 another. We use formal specifications to describe the
                 behavior of software components and, hence, to
                 determine whether two components match. We give precise
                 definitions of not just exact match, but, more
                 relevantly, various flavors of relaxed match. These
                 definitions capture the notions of generalization,
                 specialization, and substitutability of software
                 components. Since our formal specifications are pre-
                 and postconditions written as predicates in first-order
                 logic, we rely on theorem proving to determine match
                 and mismatch. We give examples from our implementation
                 of specification matching using the Larch Prover.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Documentation; Standardization; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2): {\bf Software libraries}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Modules, packages}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Pre- and post-conditions}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Specification techniques}; Information
                 Systems --- Information Storage and Retrieval ---
                 Information Search and Retrieval (H.3.3): {\bf
                 Retrieval models}; Information Systems --- Information
                 Storage and Retrieval --- Information Search and
                 Retrieval (H.3.3): {\bf Selection process}",
}

@Article{Gupta:1997:HSI,
  author =       "Rajiv Gupta and Mary Lou Soffa and John Howard",
  title =        "Hybrid slicing: integrating dynamic information with
                 static analysis",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "4",
  pages =        "370--397",
  month =        oct,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-4/p370-gupta/p370-gupta.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-4/p370-gupta/",
  abstract =     "Program slicing is an effective technique for
                 narrowing the focus of attention to the relevant parts
                 of a program during the debugging process. However,
                 imprecision is a problem in static slices, since they
                 are based on all possible executions that reach a given
                 program point rather than the specific execution under
                 which the program is being debugged. Dynamic slices,
                 based on the specific execution being debugged, are
                 precise but incur high run-time overhead due to the
                 tracing information that is collected during the
                 program's execution. We present a hybrid slicing
                 technique that integrates dynamic information from a
                 specific execution into a static slice analysis. The
                 {\em hybrid slice\/} produced is more precise that the
                 static slice and less costly that the dynamic slice.
                 The technique exploits dynamic information that is
                 readily available during debugging--namely, breakpoint
                 information and the dynamic call graph. This
                 information is integrated into a static slicing
                 analysis to more accurately estimate the potential
                 paths taken by the program. The breakpoints and
                 call/return points, used as reference points, divide
                 the execution path into intervals. By associating each
                 statement in the slice with an execution interval,
                 hybrid slicing provides information as to when a
                 statement was encountered during execution. Another
                 attractive feature of our approach is that it allows
                 the user to control the cost of hybrid slicing by
                 limiting the amount of dynamic information used in
                 computing the slice. We implemented the hybrid slicing
                 technique to demonstrate the feasibility of our
                 approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Experimentation; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "breakpoint; dynamic call graph; dynamic slice; hybrid
                 slice; static slice",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5)",
}

@Article{Zeller:1997:UVT,
  author =       "Andreas Zeller and Gregor Snelting",
  title =        "Unified versioning through feature logic",
  journal =      j-TOSEM,
  volume =       "6",
  number =       "4",
  pages =        "398--441",
  month =        oct,
  year =         "1997",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1997-6-4/p398-zeller/p398-zeller.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1997-6-4/p398-zeller/",
  abstract =     "Software configuration management (SCM) suffers from
                 tight coupling between SCM version-ing models and the
                 imposed SCM processes. In order to adapt SCM tools to
                 SCM processes, rather than vice versa, we propose a
                 unified versioning model, the {\em version set model}.
                 Version sets denote versions, components, and
                 configurations by {\em feature terms}, that is, Boolean
                 terms over ({\em feature: value\/})-attributions.
                 Through {\em feature logic}, we deduce consistency of
                 abstract configurations as well as features of derived
                 components and describe how features propagate in the
                 SCM process; using {\em feature implications}, we
                 integrate change-oriented and version-oriented SCM
                 models. We have implemented the version set model in an
                 SCM system called ICE, for {\em Incremental
                 Configuration Environment}. ICE is based on a {\em
                 featured file system (FFS)}, where version sets are
                 accessed as virtual files and directories. Using the
                 well-known C preprocessor (CPP) representation, users
                 can view and edit multiple versions simultaneously,
                 while only the differences between versions are stored.
                 It turns out that all major SCM models can be realized
                 and integrated efficiently on top of the FFS,
                 demonstrating the flexible and unifying nature of the
                 version set model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Management; Standardization; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "feature logic; version sets",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Software --- Software Engineering
                 --- Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Version control}; Software --- Software
                 Engineering --- Management (D.2.9): {\bf Software
                 configuration management}; Software --- Operating
                 Systems --- File Systems Management (D.4.3); Computing
                 Methodologies --- Artificial Intelligence --- Deduction
                 and Theorem Proving (I.2.3); Computing Methodologies
                 --- Artificial Intelligence --- Knowledge
                 Representation Formalisms and Methods (I.2.4); Software
                 --- Software Engineering --- Management (D.2.9): {\bf
                 Programming teams}",
}

@Article{Doppke:1998:SPM,
  author =       "John C. Doppke and Dennis Heimbigner and Alexander L.
                 Wolf",
  title =        "Software process modeling and execution within virtual
                 environments",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "1",
  pages =        "1--40",
  month =        jan,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-1/p1-doppke/p1-doppke.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-1/p1-doppke/",
  abstract =     "In the past, multiuser virtual environments have been
                 developed as venues for entertainment and social
                 interaction. Recent research focuses instead on their
                 utility in carrying out work in the real world. This
                 research has identified the importance of a mapping
                 between the real and the virtual that permits the
                 representation of real tasks in the virtual
                 environment. We investigate the use of virtual
                 environments--in particular, MUDs (Multi-User
                 Dimensions)--in the domain of software process. In so
                 doing, we define a mapping, or {\em metaphor}, that
                 permits the representation of software processes within
                 a MUD. The system resulting from this mapping, called
                 {\em Promo}, permits the modeling and execution of
                 software processes by geographically dispersed
                 agents.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "MOO; MUD; PROMO; software process; tools; virtual
                 environments",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Milieux --- Management
                 of Computing and Information Systems --- Software
                 Management (K.6.3); Information Systems --- Information
                 Interfaces and Presentation --- Multimedia Information
                 Systems (H.5.1): {\bf Artificial, augmented, and
                 virtual realities}; Software --- Software Engineering
                 --- Management (D.2.9): {\bf Software process models
                 (e.g., CMM, ISO, PSP)}",
}

@Article{Porter:1998:USV,
  author =       "Adam Porter and Harvey Siy and Audris Mockus and
                 Lawrence Votta",
  title =        "Understanding the sources of variation in software
                 inspections",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "1",
  pages =        "41--79",
  month =        jan,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-1/p41-porter/p41-porter.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-1/p41-porter/",
  abstract =     "In a previous experiment, we determined how various
                 changes in three structural elements of the software
                 inspection process (team size and the number and
                 sequencing of sessions) altered effectiveness and
                 interval. Our results showed that such changes did not
                 significantly influence the defect detection rate, but
                 that certain combinations of changes dramatically
                 increased the inspection interval. We also observed a
                 large amount of unexplained variance in the data,
                 indicating that other factors must be affecting
                 inspection performance. The nature and extent of these
                 other factors now have to be determined to ensure that
                 they had not biased our earlier results. Also,
                 identifying these other factors might suggest
                 additional ways to improve the efficiency of
                 inspections. Acting on the hypothesis that the
                 ``inputs'' into the inspection process (reviewers,
                 authors, and code units) were significant sources of
                 variation, we modeled their effects on inspection
                 performance. We found that they were responsible for
                 much more variation in detect detection than was
                 process structure. This leads us to conclude that
                 better defect detection techniques, not better process
                 structures, are the key to improving inspection
                 effectiveness. The combined effects of process inputs
                 and process structure on the inspection interval
                 accounted for only a small percentage of the variance
                 in inspection interval. Therefore, there must be other
                 factors which need to be identified.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Experimentation; Measurement; Performance;
                 Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "empirical studies; software inspection; software
                 process; statistical models",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Code inspections and
                 walk-throughs}; Software --- Software Engineering ---
                 Management (D.2.9): {\bf Software process models (e.g.,
                 CMM, ISO, PSP)}",
}

@Article{Baresi:1998:TFS,
  author =       "Luciano Baresi and Mauro Pezz{\`e}",
  title =        "Toward formalizing structured analysis",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "1",
  pages =        "80--107",
  month =        jan,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-1/p80-baresi/p80-baresi.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-1/p80-baresi/",
  abstract =     "Real-time extensions to structured analysis (SA/RT)
                 are popular in industrial practice. Despite the large
                 industrial experience and the attempts to formalize the
                 various ``dialects,'' SA/RT notations are still
                 imprecise and ambiguous. This article tries to identify
                 the semantic problems of the requirements definition
                 notation defined by Hatley and Pirbhai, one of the
                 popular SA/RT ``dialects,'' and discusses possible
                 solutions. As opposed to other articles that give their
                 own interpretation, this article does not propose a
                 specific semantics for the notation. This article
                 identifies imprecisions, i.e., missing or partial
                 information about features of the notation; it
                 discusses ambiguities, i.e., elements of the definition
                 that allow at least two different (``reasonable'')
                 interpretations of features of the notation; and it
                 lists extensions, i.e., features not belonging to the
                 notation, but required by many industrial users and
                 often supported by CASE tools. This article contributes
                 by clarifying whether specific interpretations can be
                 given unique semantics or retain ambiguities of the
                 original definition. The article allows for the
                 evaluation of formal definitions by indicating
                 alternatives and consequences of the specific
                 choices.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Documentation; Measurement; Performance;
                 Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Hatley and Pirbhai's requirements definition notation;
                 informal versus formal specifications; structured
                 analysis/real-time",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Coding Tools and Techniques
                 (D.2.3): {\bf Structured programming}",
}

@Article{Bowdidge:1998:SRD,
  author =       "Robert W. Bowdidge and William G. Griswold",
  title =        "Supporting the restructuring of data abstractions
                 through manipulation of a program visualization",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "2",
  pages =        "109--157",
  month =        apr,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-2/p109-bowdidge/p109-bowdidge.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-2/p109-bowdidge/",
  abstract =     "With a meaning-preserving restructuring tool, a
                 software engineer can change a program's structure to
                 ease future modifications. However, deciding how to
                 restructure the program requires a global understanding
                 of the program's structure, which cannot be derived
                 easily by directly inspecting the source code. We
                 describe a manipulable program visualization--the {\em
                 star diagram\/} --that supports the restructuring task
                 of encapsulating a global data structure. The star
                 diagram graphically displays information pertinent to
                 encapsulation, and direct manipulation of the diagram
                 causes the underlying program to be restructured. The
                 visualization compactly presents all statements in the
                 program that use the given global data structure,
                 helping the programmer to choose the functions that
                 completely encapsulate it. Additionally, the
                 visualization elides code unrelated to the data
                 structure and to the task and collapses similar
                 expressions to help the programmer identify frequently
                 occurring code fragments and manipulate them together.
                 The visualization is mapped directly to the program
                 text, so manipulation of the visualization also
                 restructures the program. We present the star diagram
                 concept and describe an implementation of the star
                 diagram built upon a meaning-preserving restructuring
                 tool for Scheme. We also describe our creation of star
                 diagram generators for C programs, and we test the
                 scalability of the star diagram using large C and MUMPS
                 programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "meaning-preserving restructuring; semi-automated
                 restructuring; software visualization; star diagram;
                 tool-supported restructuring",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf User interfaces}; Software ---
                 Software Engineering --- Distribution, Maintenance, and
                 Enhancement (D.2.7): {\bf Restructuring, reverse
                 engineering, and reengineering}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Abstract data types}",
}

@Article{Murphy:1998:ESS,
  author =       "Gail C. Murphy and David Notkin and William G.
                 Griswold and Erica S. Lan",
  title =        "An empirical study of static call graph extractors",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "2",
  pages =        "158--191",
  month =        apr,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-2/p158-murphy/p158-murphy.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-2/p158-murphy/",
  abstract =     "Informally, a call graph represents calls between
                 entities in a given program. The call graphs that
                 compilers compute to determine the applicability of an
                 optimization must typically be conservative: a call may
                 be omitted only if it can never occur in any execution
                 of the program. Numerous software engineering tools
                 also extract call graphs with the expectation that they
                 will help software engineers increase their
                 understanding of a program. The requirements placed on
                 software engineering tools that compute call graphs are
                 typically more relaxed than for compilers. For example,
                 some false negatives--calls that can in fact take place
                 in some execution of the program, but which are omitted
                 from the call graph--may be acceptable, depending on
                 the understanding task at hand. In this article, we
                 empirically show a consequence of this spectrum of
                 requirements by comparing the C call graphs extracted
                 from three software systems (mapmaker, mosaic, and gcc)
                 by nine tools (cflow, cawk, CIA, Field, GCT, Imagix,
                 LSME, Mawk, and Rigiparse). A quantitative analysis of
                 the call graphs extracted for each system shows
                 considerable variation, a result that is
                 counterintuitive to many experienced software
                 engineers. A qualitative analysis of these results
                 reveals a number of reasons for this variation:
                 differing treatments of macros, function pointers,
                 input formats, etc. The fundamental problem is not that
                 variances among the graphs extracted by different tools
                 exist, but that software engineers have little sense of
                 the dimensions of approximation in any particular call
                 graph. In this article, we describe and discuss the
                 study, sketch a design space for static call graph
                 extractors, and discuss the impact of our study on
                 practitioners, tool developers, and researchers.
                 Although this article considers only one kind of
                 information, call graphs, many of the observations also
                 apply to static extractors of other kinds of
                 information, such as inheritance structures, file
                 dependences, and references to global variables.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "call graphs; design space; empirical study; software
                 system analysis; static analysis",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4)",
}

@Article{Hunt:1998:DAE,
  author =       "James J. Hunt and Kiem-Phong Vo and Walter F. Tichy",
  title =        "Delta algorithms an empirical analysis",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "2",
  pages =        "192--214",
  month =        apr,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See addendum \cite{Hunt:1998:ADA}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-2/p192-hunt/p192-hunt.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-2/p192-hunt/",
  abstract =     "Delta algorithms compress data by encoding one file in
                 terms of another. This type of compression is useful in
                 a number of situations: strong multiple versions of
                 data, displaying differences, merging changes,
                 distributing updates, storing backups, transmitting
                 video sequences, and others. This article studies the
                 performance parameters of several delta algorithms,
                 using a benchmark of over 1,300 pairs of files taken
                 from two successive releases of GNU software. Results
                 indicate that modern delta compression algorithms based
                 on Ziv--Lempel techniques significantly outperform {\em
                 diff}, a popular but older delta compressor, in terms
                 of compression ratio. The modern compressors also
                 correlate better with the actual difference between
                 files without sacrificing performance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Experimentation; Measurement;
                 Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "benchmark; delta encoding; differencing",
  subject =      "Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf Version
                 control}; Software --- Software Engineering --- Metrics
                 (D.2.8): {\bf Performance measures}; Data --- Coding
                 and Information Theory (E.4): {\bf Data compaction and
                 compression}; Data --- Files (E.5): {\bf
                 Backup/recovery}",
}

@Article{Cook:1998:DMS,
  author =       "Jonathan E. Cook and Alexander L. Wolf",
  title =        "Discovering models of software processes from
                 event-based data",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "3",
  pages =        "215--249",
  month =        jul,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-3/p215-cook/p215-cook.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-3/p215-cook/",
  abstract =     "Many software process methods and tools presuppose the
                 existence of a formal model of a process.
                 Unfortunately, developing a formal model for an
                 on-going, complex process can be difficult, costly, and
                 error prone. This presents a practical barrier to the
                 adoption of process technologies, which would be
                 lowered by automated assistance in creating formal
                 models. To this end, we have developed a data analysis
                 technique that we term {\em process discovery.\/} Under
                 this technique, data describing process events are
                 first captured from an on-going process and then used
                 to generate a formal model of the behavior of that
                 process. In this article we describe a Markov method
                 that we developed specifically for process discovery,
                 as well as describe two additional methods that we
                 adopted from other domains and augmented for our
                 purposes. The three methods range from the purely
                 algorithmic to the purely statistical. We compare the
                 methods and discuss their application in an industrial
                 case study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Management",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Balboa; process discovery; software process; tools",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Milieux --- Management
                 of Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software development};
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3):
                 {\bf Software maintenance}",
}

@Article{Chen:1998:BWI,
  author =       "Huo Yan Chen and T. H. Tse and F. T. Chan and T. Y.
                 Chen",
  title =        "In black and white: an integrated approach to
                 class-level testing of object-oriented programs",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "3",
  pages =        "250--295",
  month =        jul,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-3/p250-chen/p250-chen.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-3/p250-chen/",
  abstract =     "Because of the growing importance of object-oriented
                 programming, a number of testing strategies have been
                 proposed. They are based either on pure black-box or
                 white-box techniques. We propose in this article a
                 methodology to integrate the black- and white-box
                 techniques. The black-box technique is used to select
                 test cases. The white-box technique is mainly applied
                 to determine whether two objects resulting from the
                 program execution of a test care are observationally
                 equivalent. It is also used to select test cases in
                 some situations. We define the concept of a fundamental
                 pair as a pair of equivalent terms that are formed by
                 replacing all the variables on both sides of an axiom
                 by normal forms. We prove that an implementation is
                 consistent with respect to all equivalent terms if and
                 only if it is consistent with respect to all
                 fundamental pairs. In other words, the testing coverage
                 of fundamental pairs is as good as that of all possible
                 term rewritings, and hence we need only concentrate on
                 the testing of fundamental pairs. Our strategy is based
                 on mathematical theorems. According to the strategy, we
                 propose an algorithm for selecting a finite set of
                 fundamental pairs as test cases. Given a pair of
                 equivalent terms as a test case, we should then
                 determine whether the objects that result from
                 executing the implemented program are observationally
                 equivalent. We prove, however, that the observational
                 equivalence of objects cannot be determined using a
                 finite set of observable contexts (which are operation
                 sequences ending with an observer function) derived
                 from any black-box technique. Hence we supplement our
                 approach with a ``relevant observable context''
                 technique, which is a heuristic white-box technique to
                 select a relevant finite subset of the set of
                 observable contexts for determining the observational
                 equivalence. The relevant observable contexts are
                 constructed from a data member relevance graph (DRG),
                 which is an abstraction of the given implementation for
                 a given specification. A semiautomatic tool hass been
                 developed to support this technique.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Languages; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstract data types; algebraic specification;
                 object-oriented programming; observational equivalence;
                 software-testing methodologies",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Software --- Programming Languages
                 --- Language Classifications (D.3.2): {\bf
                 Object-oriented languages}",
}

@Article{Crow:1998:FSS,
  author =       "Judith Crow and Ben {Di Vito}",
  title =        "Formalizing space shuttle software requirements: four
                 case studies",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "3",
  pages =        "296--332",
  month =        jul,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-3/p296-crow/p296-crow.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-3/p296-crow/",
  abstract =     "This article describes four case studies in which
                 requirements for new flight software subsystems on
                 NASA's Space Shuttle were analyzed using mechanically
                 supported formal methods. Three of the studies used
                 standard formal specification and verification
                 techniques, and the fourth used state exploration.
                 These applications illustrate two thesis: (1) formal
                 methods complement conventional requirements analysis
                 processes effectively and (2) formal methods confer
                 benefits even when only selectively adopted and
                 applied. The studies also illustrate the interplay of
                 application maturity level and formal methods strategy,
                 especially in areas such as technology transfer, legacy
                 applications, and rapid formalization, and they raise
                 interesting issues in problem domain modeling and in
                 tailoring formal techniques to applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "flight software; formal methods; requirements
                 analysis; space shuttle; state exploration; theorem
                 proving",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Tools}; Theory of Computation --- Logics
                 and Meanings of Programs --- Specifying and Verifying
                 and Reasoning about Programs (F.3.1): {\bf Logics of
                 programs}; Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1): {\bf Mechanical
                 verification}; Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1): {\bf Specification
                 techniques}",
}

@Article{Allen:1998:EFB,
  author =       "Robert Allen and David Garlan",
  title =        "Errata: {``A formal basis for architectural
                 connection''}",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "3",
  pages =        "333--334",
  month =        jul,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See \cite{Allen:1997:FBA}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-3/p333-allen/p333-allen.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-3/p333-allen/",
  abstract =     "We present corrections to a previously published
                 article which appeared in {\em ACM Transaction on
                 Software Engineering and Methodology\/} 6, 3 (July
                 1997), pp. 213-249",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal models; model-checking; module interconnection;
                 software analysis; WRIGHT",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Specification techniques}; Theory of
                 Computation --- Mathematical Logic and Formal Languages
                 --- Formal Languages (F.4.3)",
}

@Article{Hunter:1998:MIS,
  author =       "Anthony Hunter and Bashar Nuseibeh",
  title =        "Managing inconsistent specifications: reasoning,
                 analysis, and action",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "4",
  pages =        "335--367",
  month =        oct,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-4/p335-hunter/p335-hunter.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-4/p335-hunter/",
  abstract =     "In previous work, we advocated continued development
                 of specifications in the presence of inconsistency. To
                 support this, we used classical logic to represent
                 partial specifications and to identify inconsistencies
                 between them. We now present an adaptation of classical
                 logic, which we term quasi-classical (QC) logic, that
                 allows continued reasoning in the presence of
                 inconsistency. The adaptation is a weakening of
                 classical logic that prohibits all trivial derivations,
                 but still allows all resolvants of the assumptions to
                 be derived. Furthermore, the connectives behave in a
                 classical manner. We then present a development called
                 labeled QC logic that records and tracks assumptions
                 used in reasoning. This facilitates a logical analysis
                 of inconsistent information. We discuss that
                 application of labeled QC logic in the analysis of
                 multiperspective specifications. Such specifications
                 are developed by multiple participants who hold
                 overlapping, often inconsistent, views of the systems
                 they are developing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "managing inconsistency; paraconsistent logics;
                 requirements specification; viewpoints",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Software/Program Verification (D.2.4): {\bf
                 Validation}; Software --- Software Engineering ---
                 Testing and Debugging (D.2.5): {\bf Error handling and
                 recovery}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Restructuring, reverse engineering, and
                 reengineering}; Theory of Computation --- Mathematical
                 Logic and Formal Languages --- Mathematical Logic
                 (F.4.1): {\bf Proof theory}; Software --- Software
                 Engineering --- General (D.2.0); Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2)",
}

@Article{Jaccheri:1998:ESP,
  author =       "Maria Letizia Jaccheri and Gian Pietro Picco and
                 Patricia Lago",
  title =        "Eliciting software process models with the {E3}
                 language",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "4",
  pages =        "368--410",
  month =        oct,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-4/p368-jaccheri/p368-jaccheri.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-4/p368-jaccheri/",
  abstract =     "Software processes are complex entities that demand
                 careful understand ing and improvement as they
                 determine the quality of the resulting product. A
                 necessary step toward the improvement of an
                 organization's process is a clear description of the
                 entities involved and of their mutual relationships.
                 Process model {\em elicitation\/} aims at constructing
                 this description under the shape of a software process
                 model. The model is constructed by gathering, from
                 several sources, process information which is often
                 incomplete, inconsistent, and ambiguous. A process
                 modeling language can be used to represent the model
                 being elicited. However, elicitation requires process
                 models to be understandable and well structured. These
                 requirements are often not satisfied by available
                 process modeling languages because of their bias toward
                 process enaction rather than process description. This
                 article presents a process modeling language and a
                 support tool which are conceived especially for process
                 model elicitation. The {\em E\/} 3 language is an
                 object-oriented modeling language with a graphical
                 notation. In {\em E\/} 3, associations are a means to
                 express constraints and facilitate reuse. The {\em E\/}
                 3 p-draw tool supports the creation and management of
                 {\em E\/} 3 models and provides a view mechanism that
                 enables inspection of models according to different
                 perspectives.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Documentation; Languages; Management",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "associations; process model elicitation; software
                 process modeling",
  subject =      "Software --- Programming Techniques ---
                 Object-oriented Programming (D.1.5); Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1); Software --- Software Engineering --- Design
                 Tools and Techniques (D.2.2): {\bf Computer-aided
                 software engineering (CASE)}; Software --- Software
                 Engineering --- Management (D.2.9): {\bf Software
                 configuration management}; Computing Milieux ---
                 Management of Computing and Information Systems ---
                 Software Management (K.6.3): {\bf Software
                 development}; Computing Milieux --- Management of
                 Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software maintenance}",
}

@Article{Fuggetta:1998:AGI,
  author =       "Alfonso Fuggetta and Luigi Lavazza and Sandro Morasca
                 and Stefano Cinti and Giandomenico Oldano and Elena
                 Orazi",
  title =        "Applying {GQM} in an industrial software factory",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "4",
  pages =        "411--448",
  month =        oct,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-4/p411-fuggetta/p411-fuggetta.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-4/p411-fuggetta/",
  abstract =     "Goal/Question/Metric (GQM) is a paradigm for the
                 systematic definition, establishment, and exploitation
                 of measurement programs supporting the quantitative
                 evaluation of software processes and products. Although
                 GQM is a quite well-known method, detailed guidelines
                 for establishing a GQM program in an industrial
                 environment are still limited. Also, there are few
                 reported experiences on the application of GQM to
                 industrial cases. Finally, the technological support
                 for GQM is still inadequate. This article describes the
                 experience we have gained in applying GQM at Digital
                 Laboratories in Italy. The procedures, experiences, and
                 technology that have been employed in this study are
                 largely reusable by other industrial organizations
                 willing to introduce a GQM-based measurement program in
                 their development environments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Management; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "GQM; measurement cost; measurement process",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Metrics (D.2.8): {\bf Performance measures};
                 Software --- Software Engineering --- Management
                 (D.2.9): {\bf Productivity}; Software --- Software
                 Engineering --- Management (D.2.9): {\bf Software
                 quality assurance (SQA)}",
}

@Article{Hunt:1998:ADA,
  author =       "James J. Hunt and Walter F. Tichy",
  title =        "Addendum to {``Delta algorithms: an empirical
                 analysis''}",
  journal =      j-TOSEM,
  volume =       "7",
  number =       "4",
  pages =        "449--449",
  month =        oct,
  year =         "1998",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  note =         "See \cite{Hunt:1998:DAE}.",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1998-7-4/p449-hunt/p449-hunt.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1998-7-4/p449-hunt/",
  abstract =     "The authors supply machine configurations for
                 experiments reported in ``Delta Algorithms: An
                 Empirical Analysis,'' by Hunt et al. ({\em ACM Trans.
                 Softw. Eng. Methodol.\/} 7, 2 (Apr. 1998), pp.
                 192-214).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "benchmark; delta encoding; differencing",
  subject =      "Software --- Software Engineering --- Distribution,
                 Maintenance, and Enhancement (D.2.7): {\bf Version
                 control}; Software --- Software Engineering --- Metrics
                 (D.2.8): {\bf Performance measures}; Data --- Coding
                 and Information Theory (E.4): {\bf Data compaction and
                 compression}; Data --- Files (E.5): {\bf
                 Backup/recovery}",
}

@Article{Ostroff:1999:CRD,
  author =       "Jonathan S. Ostroff",
  title =        "Composition and refinement of discrete real-time
                 systems",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "1",
  pages =        "1--48",
  month =        jan,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-1/p1-ostroff/p1-ostroff.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-1/p1-ostroff/",
  abstract =     "Reactive systems exhibit ongoing, possibly
                 nonterminating, interaction with the environment.
                 Real-time systems are reactive systems that must
                 satisfy quantitative timing constraints. This paper
                 presents a structured compositional design method for
                 discrete real-time systems that can be used to combat
                 the combinatorial explosion of states in the
                 verification of large systems. A {\em composition
                 rule\/} describes how the correctness of the system can
                 be determined from the correctness of its modules,
                 without knowledge of their internal structure. The
                 advantage of compositional verification is clear. Each
                 module is both simpler and smaller than the system
                 itself. Composition requires the use of both
                 model-checking and deductive techniques. A {\em
                 refinement rule\/} guarantees that specifications of
                 high-level modules are preserved by their
                 implementations. The {\em StateTime\/} toolset is used
                 to automate parts of compositional designs using a
                 combination of model-checking and simulation. The
                 design method is illustrated using a reactor shutdown
                 system that cannot be verified using the StateTime
                 toolset (due to the combinatorial explosion of states)
                 without compositional reasoning. The reactor example
                 also illustrates the use of the refinement rule.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstraction; model-checking; modules; refinement;
                 state explosion; temporal logic; timed logic",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3); Software --- Software Engineering
                 --- Design** (D.2.10); Software --- Software
                 Engineering --- Requirements/Specifications (D.2.1):
                 {\bf Methodologies (e.g., object-oriented,
                 structured)}; Software --- Software Engineering ---
                 Software/Program Verification (D.2.4): {\bf Model
                 checking}; Software --- Software Engineering --- Design
                 Tools and Techniques (D.2.2): {\bf Modules and
                 interfaces}; Software --- Software Engineering ---
                 Design Tools and Techniques (D.2.2); Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1): {\bf Tools}; Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf State
                 diagrams}; Software --- Software Engineering ---
                 Software/Program Verification (D.2.4)",
}

@Article{Cheung:1999:CSP,
  author =       "Shing Chi Cheung and Jeff Kramer",
  title =        "Checking safety properties using compositional
                 reachability analysis",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "1",
  pages =        "49--78",
  month =        jan,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-1/p49-cheung/p49-cheung.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-1/p49-cheung/",
  abstract =     "The software architecture of a distributed program can
                 be represented by a hierarchical composition of
                 subsystems, with interacting processes at the leaves of
                 the hierarchy. Compositional reachability analysis
                 (CRA) is a promising state reduction technique which
                 can be automated and used in stages to derive the
                 overall behavior of a distributed program based on its
                 architecture. CRA is particularly suitable for the
                 analysis of programs that are subject to evolutionary
                 change. When a program evolves, only the behaviors of
                 those subsystems affected by the change need be
                 reevaluated. The technique however has a limitation.
                 The properties available for analysis are constrained
                 by the set of actions that remain globally observable.
                 Properties involving actions encapsulated by subsystems
                 may therefore not be analyzed. In this article, we
                 enhance the CRA technique to check safety properties
                 which may contain actions that are not globally
                 observable. To achieve this, the state machine model is
                 augmented with a special trap state labeled as ?. We
                 propose a scheme to transform, in stages, a property
                 that involves hidden actions to one that involves only
                 globally observable actions. The enhanced technique
                 also includes a mechanism aiming at reducing the
                 debugging effort. The technique is illustrated using a
                 gas station system example.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "compositional reachability analysis; distributed
                 systems; model checking; safety properties; static
                 analysis",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Software Engineering ---
                 Software/Program Verification (D.2.4); Software ---
                 Software Engineering --- Management (D.2.9): {\bf
                 Software quality assurance (SQA)}",
}

@Article{Ciapessoni:1999:FMF,
  author =       "Emanuele Ciapessoni and Piergiorgio Mirandola and
                 Alberto Coen-Porisini and Dino Mandrioli and Angelo
                 Morzenti",
  title =        "From formal models to formally based methods: an
                 industrial experience",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "1",
  pages =        "79--113",
  month =        jan,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-1/p79-ciapessoni/p79-ciapessoni.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-1/p79-ciapessoni/",
  abstract =     "We address the problem of increasing the impact of
                 formal methods in the practice of industrial computer
                 applications. We summarize the reasons why formal
                 methods so far did not gain widespead use within the
                 industrial environment despite several promising
                 experiences. We suggest an evolutionary rather than
                 revolutionary attitude in the introduction of formal
                 methods in the practice of industrial applications, and
                 we report on our long-standing experience which
                 involves an academic institution. Politecnico di
                 Milano, two main industrial partners, ENEL and CISE,
                 and occasionally a few other industries. Our approach
                 aims at augmenting an existing and fairly deeply rooted
                 informal industrial methodology with our original
                 formalism, the logic specification language TRIO. On
                 the basis of the experiences we gained we argue that
                 our incremental attitude toward the introduction of
                 formal methods within the industry could be effective
                 largely independently from the chosen formalism.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Documentation; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal models; industrial applications; object
                 orientation; specification; supervision and control;
                 technology transfer",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Methodologies
                 (e.g., object-oriented, structured)}; Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2); Software --- Software Engineering ---
                 Software/Program Verification (D.2.4)",
}

@Article{McCann:1999:MMI,
  author =       "Peter J. McCann and Gruia-Catalin Roman",
  title =        "Modeling mobile {IP} in mobile {UNITY}",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "2",
  pages =        "115--146",
  month =        apr,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-2/p115-mccann/p115-mccann.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-2/p115-mccann/",
  abstract =     "With recent advances in wireless communication
                 technology, mobile computing is an increasingly
                 important area of research. A mobile system is one
                 where independently executing components may migrate
                 through some space during the course of the
                 computation, and where the pattern of connectivity
                 among the components changes as they move in and out of
                 proximity. Mobile UNITY is a notation and proof logic
                 for specifying and reasoning about mobile systems. In
                 this article it is argued that Mobile UNITY contributes
                 to the modular development of system specifications
                 because of the declarative fashion in which
                 coordination among components is specified. The
                 packet-forwarding mechanism at the core of the Mobile
                 IP protocol for routing to mobile hosts is taken as an
                 example. A Mobile UNITY model of packet forwarding and
                 the mobile system in which it must operate is
                 developed. Proofs of correctness properties, including
                 important real-time properties, are outlined, and the
                 role of formal verification in the development of
                 protocols such as Mobile IP is discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Reliability; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "formal methods; mobile computing; mobile UNITY; shared
                 variables; synchronization; transient interactions;
                 weak consistency",
  subject =      "Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2): {\bf IP}; Computer Systems Organization ---
                 Computer-Communication Networks --- Network
                 Architecture and Design (C.2.1): {\bf Wireless
                 communication}; Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2): {\bf Protocol verification}",
}

@Article{Cook:1999:SPV,
  author =       "Jonathan E. Cook and Alexander L. Wolf",
  title =        "Software process validation: quantitatively measuring
                 the correspondence of a process to a model",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "2",
  pages =        "147--176",
  month =        apr,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-2/p147-cook/p147-cook.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-2/p147-cook/",
  abstract =     "To a great extent, the usefulness of a formal model of
                 a software process lies in its ability to accurately
                 predict the behavior of the executing process.
                 Similarly, the usefulness of an executing process lies
                 largely in its ability to fulfill the requirements
                 embodied in a formal model of the process. When process
                 models and process executions diverge, something
                 significant is happening. We have developed techniques
                 for uncovering and measuring the discrepancies between
                 models and executions, which we call {\em process
                 validation}. Process validation takes a process
                 execution and a process model, and measures the level
                 of correspondence between the two. Our metrics are
                 tailorable and give process engineers control over
                 determining the severity of different types of
                 discrepancies. The techniques provide detailed
                 information once a high-level measurement indicates the
                 presence of a problem. We have applied our processes
                 validation methods in an industrial case study, of
                 which a portion is described in this article.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Management; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "balboa; process validation; software process; tools",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6); Computing Milieux --- Management
                 of Computing and Information Systems --- Software
                 Management (K.6.3): {\bf Software development};
                 Computing Milieux --- Management of Computing and
                 Information Systems --- Software Management (K.6.3):
                 {\bf Software maintenance}; Software --- Software
                 Engineering --- Metrics (D.2.8): {\bf Process
                 metrics}",
}

@Article{Devanbu:1999:GCF,
  author =       "Premkumar T. Devanbu",
  title =        "{GENOA} --- a customizable, front-end-retargetable
                 source code analysis framework",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "2",
  pages =        "177--212",
  month =        apr,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-2/p177-devanbu/p177-devanbu.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-2/p177-devanbu/",
  abstract =     "{\em Code analysis\/} tools provide support for such
                 software engineering tasks as program understanding,
                 software metrics, testing, and reengineering. In this
                 article we describe GENOA, the framework underlying
                 application generators such as Aria and GEN++ which
                 have been used to generate a wide range of practical
                 code analysis tools. This experience illustrates {\em
                 front-end retargetability\/} of GENOA; we describe the
                 features of the GENOA framework that allow it to be
                 used with different front ends. While permitting
                 arbitrary parse tree computations, the GENOA
                 specification language has special, compact iteration
                 operators that are tuned for expressing simple,
                 polynomial-time analysis programs; in fact, there is a
                 useful sublanguage of the GENOA language that can
                 express precisely all (and only) {\em
                 polynomial-time\/} (PTIME) analysis programs on parse
                 trees. Thus, we argue that the GENOA language is a
                 simple and convenient vehicle for implementing a range
                 of analysis tools. We also argue that the ``front-and
                 reuse'' approach of GENOA offers an important advantage
                 for tools aimed at large software projects: the reuse
                 of complex, expensive build procedures to run generated
                 tools over large source bases. In this article, we
                 describe the GENOA framework and our experiences with
                 it.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "code inspection; metrics; reverse engineering; source
                 analysis",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4); Software --- Software Engineering --- Coding
                 Tools and Techniques (D.2.3); Software --- Software
                 Engineering --- Programming Environments (D.2.6);
                 Software --- Software Engineering --- Software
                 Architectures (D.2.11); Software --- Software
                 Engineering --- Testing and Debugging (D.2.5); Software
                 --- Software Engineering --- Metrics (D.2.8)",
}

@Article{Damiani:1999:HAA,
  author =       "E. Damiani and M. G. Fugini and C. Bellettini",
  title =        "A hierarchy-aware approach to faceted classification
                 of objected-oriented components",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "3",
  pages =        "215--262",
  month =        jul,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-3/p215-damiani/p215-damiani.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-3/p215-damiani/",
  abstract =     "This article presents a hierarchy-aware classification
                 schema for obje ct-oriented code, where software
                 components are classified according to their {\em
                 behavioral characteristics}, such as provided services,
                 employed algorithms, and needed data. In the case of
                 reusable application frameworks, these characteristics
                 are constructed from their {\em model}, i.e., from the
                 description of the abstract classes specifying both the
                 framework structure and purpose. In conventional object
                 libraries, the characteristics are extracted
                 semiautomatically from class interfaces.
                 Characteristics are term pairs, weighted to represent
                 ``how well'' they describe component behavior. The set
                 of characteristics associated with a given component
                 forms its {\em software descriptor}. A descriptor base
                 is presented where descriptors are organized on the
                 basis of structured relationships, such as similarity
                 and composition. The classification is supported by a
                 thesaurus acting as a language-independent unified
                 lexicon. The descriptor base is conceived for
                 developers who, besides conventionally browsing the
                 descriptors hierarchy, can query the system, specifying
                 a set of desired functionalities and getting a ranked
                 set of adaptable candidates. User feedback is taken
                 into account in order to progressively ameliorate the
                 quality of the descriptors according to the views of
                 the user community. Feedback is made dependent of the
                 user typology through a {\em user profile}.
                 Experimental results in terms of recall and precision
                 of the retrieval mechanism against a sample code base
                 are reported.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Documentation",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "code analysis; component repositories; component
                 retrieval; software reuse; user feedback",
  subject =      "Information Systems --- Information Storage and
                 Retrieval --- Information Search and Retrieval
                 (H.3.3)",
}

@Article{Podgurski:1999:ESR,
  author =       "Andy Podgurski and Wassim Masri and Yolanda McCleese
                 and Francis G. Wolff and Charles Yang",
  title =        "Estimation of software reliability by stratified
                 sampling",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "3",
  pages =        "263--283",
  month =        jul,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-3/p263-podgurski/p263-podgurski.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-3/p263-podgurski/",
  abstract =     "A new approach to software reliability estimation is
                 presented that combines operational testing with
                 stratified sampling in order to reduce the number of
                 program executions that must be checked manually for
                 conformance to requirements. Automatic cluster analysis
                 is applied to execution profiles in order to stratify
                 captured operational executions. Experimental results
                 are reported that suggest this approach can
                 significantly reduce the cost of estimating
                 reliability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "beta testing; cluster analysis; operational testing;
                 software reliability; software testing; statistical
                 testing; stratified sampling",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Software libraries}; Software
                 --- Software Engineering --- Testing and Debugging
                 (D.2.5); Software --- Operating Systems --- Reliability
                 (D.4.5); Software --- Software Engineering --- Design
                 Tools and Techniques (D.2.2)",
}

@Article{Jezequel:1999:RVC,
  author =       "Jean-Marc J{\'e}z{\'e}quel",
  title =        "Reifying variants in configuration management",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "3",
  pages =        "284--295",
  month =        jul,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-3/p284-jezequel/p284-jezequel.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-3/p284-jezequel/",
  abstract =     "Using a solid software configuration management (SCM)
                 is mandatory to establish and maintain the integrity of
                 the products of a software project throughout the
                 project's software life cycle. Even with the help of
                 sophisticated tools, handling the various dimensions of
                 SCM can be a daunting (and costly) task for many
                 projects. The contribution of this article is to (1)
                 propose a method (based on the use creational design
                 patterns) to simplify SCM by reifying the {\em
                 variants\/} of an object-oriented software system into
                 language-level objects and (2) show that newly
                 available compilation technology makes this proposal
                 attractive with respect to performance (memory
                 footprint and execution time) by inferring which
                 classes are needed for a specific configuration and
                 optimizing the generated code accordingly.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Management; Performance",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "compilation technology; Eiffel; Mecure;
                 object-oriented analysis and design; reifying variants;
                 SMDS; software configuration management",
  subject =      "Software --- Software Engineering (D.2); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2): {\bf Software libraries}; Software ---
                 Software Engineering --- Management (D.2.9): {\bf
                 Software configuration management}",
}

@Article{Reiss:1999:DE,
  author =       "Steven P. Reiss",
  title =        "The {Desert} environment",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "4",
  pages =        "297--342",
  month =        oct,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-4/p297-reiss/p297-reiss.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-4/p297-reiss/",
  abstract =     "The Desert software engineering environment is a suite
                 of tools developed to enhance programmer productivity
                 through increased tool integration. It introduces an
                 inexpensive form of data integration to provide
                 additional tool capabilities and information sharing
                 among tools, uses a common editor to give high-quality
                 semantic feedback and to integrate different types of
                 software artifacts, and builds virtual files on demand
                 to address specific tasks. All this is done in an open
                 and extensible environment capable of handling large
                 software systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "integrated programming environments; program editors",
  subject =      "Software --- Software Engineering --- Coding Tools and
                 Techniques (D.2.3); Software --- Software Engineering
                 --- Programming Environments (D.2.6)",
}

@Article{Pohl:1999:PTP,
  author =       "Klaus Pohl and Klaus Weidenhaupt and Ralf D{\"o}mges
                 and Peter Haumer and Matthias Jarke and Ralf Klamma",
  title =        "{PRIME} --- toward process-integrated modeling
                 environments: 1",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "4",
  pages =        "343--410",
  month =        oct,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-4/p343-pohl/p343-pohl.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-4/p343-pohl/",
  abstract =     "Research in process-centered environments (PCEs) has
                 focused on project management support and has neglected
                 method guidance for the engineers performing the
                 (software) engineering process. It has been dominated
                 by the search for suitable process-modeling languages
                 and enactment mechanisms. The consequences of process
                 orientation on the computer-based engineering
                 environments, i.e., the interactive tools used during
                 process performance, have been studied much less. In
                 this article, we present the PRIME (Process Integrated
                 Modeling Environments) framework which empowers method
                 guidance through process-integrated tools. In contrast
                 to the tools of PCEs, the process-integrated tools of
                 PRIME adjust their behavior according to the current
                 process situation and the method definitions. Process
                 integration of PRIME tools is achieved through (1) the
                 definition of tool models; (2) the integration of the
                 tool models and the method definitions; (3) the
                 interpretation of the integrated environment model by
                 the tools, the process-aware control integration
                 mechanism, and the enactment mechanism; and (4) the
                 synchronization of the tools and the enactment
                 mechanism based on a comprehensive interaction
                 protocol. We sketch the implementation of PRIME as a
                 reusable implementation framework which facilitates the
                 realization of process-integrated tools as well as the
                 process integration of external tools. We define a
                 six-step procedure for building a PRIME-based
                 process-integrated environment (PIE) and illustrate how
                 PRIME facilitates change integration on an
                 easy-to-adapt modeling level.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Human Factors; Management; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "method guidance; PRIME; process modeling;
                 process-centered environments; process-integrated
                 environments; process-sensitive tools; tool
                 integration; tool modeling",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Tools};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Computer-aided software
                 engineering (CASE)}; Software --- Software Engineering
                 --- Programming Environments (D.2.6): {\bf Interactive
                 environments}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf
                 Frameworks}; Information Systems --- Information
                 Systems Applications --- Office Automation (H.4.1):
                 {\bf Workflow management}; Computer Applications ---
                 Computer-Aided Engineering (J.6); Computing Milieux ---
                 Management of Computing and Information Systems ---
                 Software Management (K.6.3): {\bf Software process};
                 Software --- Software Engineering --- Programming
                 Environments (D.2.6): {\bf Integrated environments}",
}

@Article{Kuhn:1999:FCE,
  author =       "D. Richard Kuhn",
  title =        "Fault classes and error detection capability of
                 specification-based testing",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "4",
  pages =        "411--424",
  month =        oct,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-4/p411-kuhn/p411-kuhn.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-4/p411-kuhn/",
  abstract =     "Some varieties of specification-based testing rely
                 upon methods for generating test cases from predicates
                 in a software specification. These methods derive
                 various test conditions from logic expressions, with
                 the aim of detecting different types of faults. Some
                 authors have presented empirical results on the ability
                 of specification-based test generation methods to
                 detect failures. This article describes a method for
                 computing the conditions that must be covered by a test
                 set for the test set to guarantee detection of the
                 particular fault class. It is shown that there is a
                 coverage hierarchy to fault classes that is consistent
                 with, and may therefore explain, experimental results
                 on fault-based testing. The method is also shown to be
                 effective for computing MCDC-adequate tests.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Experimentation; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "testing",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4); Software --- Software Engineering
                 --- Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Testing and Debugging
                 (D.2.5)",
}

@Article{Damiani:1999:CHA,
  author =       "E. Damiani and M. G. Fugini and C. Bellettini",
  title =        "Corrigenda: a hierarchy-aware approach to faceted
                 classification of object-oriented components",
  journal =      j-TOSEM,
  volume =       "8",
  number =       "4",
  pages =        "425--472",
  month =        oct,
  year =         "1999",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/1999-8-4/p425-damiani/p425-damiani.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/1999-8-4/p425-damiani/",
  abstract =     "This article presents a hierarchy-aware classification
                 schema for object-oriented code, where software
                 components are classified according to their {\em
                 behavioral characteristics}, such as provided services,
                 employed algorithms, and needed data. In the case of
                 reusable application frameworks, these characteristics
                 are constructed from their {\em model}, i.e., from the
                 description of the abstract classes specifying both the
                 framework structure and purpose. In conventional object
                 libraries, the characteristics are extracted
                 semiautomatically from class interfaces.
                 Characteristics are term pairs, weighted to represent
                 ``how well'' they describe component behavior. The set
                 of characteristics associated with a given component
                 forms its {\em software descriptor}. A descriptor base
                 is presented where descriptors are organized on the
                 basis of structured relationships, such as similarity
                 and composition. The classification is supported by a
                 thesaurus acting as a language-independent unified
                 lexicon. The descriptor base is conceived for
                 developers who, besides conventionally browsing the
                 descriptors hierarchy, can query the system, specifying
                 a set of desired functionalities and getting a ranked
                 set of adaptable candidates. User feedback is taken
                 into account in order to progressively ameliorate the
                 quality of the descriptors according to the views of
                 the user community. Feedback is made dependent of the
                 user typology through a {\em user profile}.
                 Experimental results in terms of recall and precision
                 of the retrieval mechanism against a sample code base
                 are reported.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Information Systems --- Information Storage and
                 Retrieval --- Information Search and Retrieval (H.3.3):
                 {\bf Information filtering}",
}

@Article{Bultan:2000:CMC,
  author =       "Tevfik Bultan and Richard Gerber and Christopher
                 League",
  title =        "Composite model-checking: verification with
                 type-specific symbolic representations",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "1",
  pages =        "3--50",
  month =        jan,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-1/p3-bultan/p3-bultan.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-1/p3-bultan/",
  abstract =     "There has been a surge of progress in automated
                 verification methods based on state exploration. In
                 areas like hardware design, these technologies are
                 rapidly augmenting key phases of testing and
                 validation. To date, one of the most successful of
                 these methods has been symbolic model-checking, in
                 which large finite-state machines are encoded into
                 compact data structures such as Binary Decision
                 Diagrams (BDDs), and are then checked for safety and
                 liveness properties. However, these techniques have not
                 realized the same success on software systems. One
                 limitation is their inability to deal with
                 infinite-state programs, even those with a single
                 unbounded integer. A second problem is that of finding
                 efficient representations for various variable types.
                 We recently proposed a model-checker for integer-based
                 systems that uses arithmetic constraints as the
                 underlying state representation. While this approach
                 easily verified some subtle, infinite-state concurrency
                 problems, it proved inefficient in its treatment of
                 boolean and (unordered) enumerated types--which are not
                 efficiently representable using arithmetic constraints.
                 In this article we present a new technique that
                 combines the strengths of both BDD and arithmetic
                 constraint representations. Our composite model merges
                 multiple type-specific symbolic representations in a
                 single model-checker. A system's transitions and
                 fixpoint computations are encoded using both BDD (for
                 boolean and enumerated types) and arithmetic
                 constraints (for integers) representations, where the
                 choice depends on the variable types. Our composite
                 model-checking strategy can be extended to other
                 symbolic representations provided that they support
                 operations such as intersection, union, complement,
                 equivalence checking, and relational image computation.
                 We also present conservative approximation techniques
                 for composite representations to address the
                 undecidability of model-checking on infinite-state
                 systems. We demonstrate the effectiveness of our
                 approach by analyzing two example software
                 specifications which include a mixture of booleans,
                 integers, and enumerated types. One of them is a
                 requirements specification for the control software of
                 a nuclear reactor's cooling system, and the other one
                 is a protocol specification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "binary decision diagrams; Presburger arithmetic;
                 symbolic model-checking",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Formal methods}; Software
                 --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Model checking}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1); Theory of Computation --- Logics and Meanings
                 of Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Invariants}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Mechanical verification}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Pre- and post-conditions}; Software ---
                 Software Engineering --- Requirements/Specifications
                 (D.2.1); Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Tools}",
}

@Article{Corbett:2000:USA,
  author =       "James C. Corbett",
  title =        "Using shape analysis to reduce finite-state models of
                 concurrent {Java} programs",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "1",
  pages =        "51--93",
  month =        jan,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-1/p51-corbett/p51-corbett.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-1/p51-corbett/",
  abstract =     "Finite-state verification (e.g., model checking)
                 provides a powerful means to detect concurrency errors,
                 which are often subtle and difficult to reproduce.
                 Nevertheless, widespread use of this technology by
                 developers is unlikely until tools provide automated
                 support for extracting the required finite-state models
                 directly from program source. Unfortunately, the
                 dynamic features of modern languages such as Java
                 complicate the construction of compact finite-state
                 models for verification. In this article, we show how
                 shape analysis, which has traditionally been used for
                 computing alias information in optimizers, can be used
                 to greatly reduce the size of finite-state models of
                 concurrent Java programs by determining which
                 heap-allocated variables are accessible only by a
                 single thread, and which shared variables are protected
                 by locks. We also provide several other state-space
                 reductions based on the semantics of Java monitors. A
                 prototype of the reductions demonstrates their
                 effectiveness.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concurrent systems; finite-state verification; Java;
                 model extraction; modeling; shape analysis; state-space
                 reductions",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4)",
}

@Article{Gunter:2000:ADB,
  author =       "Carl A. Gunter",
  title =        "Abstracting dependencies between software
                 configuration items",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "1",
  pages =        "94--131",
  month =        jan,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-1/p94-gunter/p94-gunter.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-1/p94-gunter/",
  abstract =     "This article studies an abstract model of dependencies
                 between software configuration items based on a theory
                 of concurrent computation over a class of Petri nets
                 called {\em production\/} nets. A general theory of
                 build optimizations and their correctness is developed
                 based on a form of abstract interpretation called a
                 {\em build abstraction\/}; these are created during a
                 build and are used to optimize subsequent builds.
                 Various examples of such optimizations are discussed.
                 The theory is used to show how properties can be
                 characterized and proved, and how optimizations can be
                 composed and compared.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstract interpretation; mathematical models of build
                 dependencies; Petri nets; software configuration
                 management",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4); Software --- Software Engineering
                 --- Distribution, Maintenance, and Enhancement (D.2.7):
                 {\bf Restructuring, reverse engineering, and
                 reengineering}; Software --- Software Engineering ---
                 Distribution, Maintenance, and Enhancement (D.2.7);
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Semantics of Programming Languages
                 (F.3.2)",
}

@Article{Sistla:2000:SSB,
  author =       "A. Prasad Sistla and Viktor Gyuris and E. Allen
                 Emerson",
  title =        "{SMC}: a symmetry-based model checker for verification
                 of safety and liveness properties",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "2",
  pages =        "133--166",
  month =        apr,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-2/p133-sistla/p133-sistla.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-2/p133-sistla/",
  abstract =     "The article presents the SMC system. SMC can be used
                 for checking safety and liveness properties of
                 concurrent programs under different fairness
                 assumptions. It is based on explicit state enumeration.
                 It combats the state explosion by exploiting symmetries
                 of the input concurrent program, usually present in the
                 form of identical processes, in two different ways.
                 Firstly, it reduces the number of explored states by
                 identifying those states that are equivalent under the
                 symmetries of the system; this is called {\em process
                 symmetry}. Secondly, it reduces the number of edges
                 explored from each state, in0 the reduced state graph,
                 by exploiting the symmetry of a single state; this is
                 called {\em state symmetry}. SMC works in an {\em
                 on-the-fly\/} manner; it constructs the reduced state
                 graph as and when it is needed. This method facilitates
                 early termination, speeds up model checking, and
                 reduces memory requirements. We employed SMC to check
                 the correctness of, among other standard examples, the
                 Link Layer part of the IEEE Standard 1394 ``Firewire''
                 high-speed serial bus protocol. SMC found deadlocks in
                 the protocol. SMC was also to check certain liveness
                 properties. A report on the case study is included in
                 the article.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Performance; Standardization;
                 Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automata; model checking",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Model checking}; Software
                 --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Formal methods}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Mechanical verification}; Software ---
                 Programming Techniques --- Concurrent Programming
                 (D.1.3)",
}

@Article{Ciancarini:2000:UCL,
  author =       "P. Ciancarini and F. Franz{\'e} and C. Mascolo",
  title =        "Using a coordination language to specify and analyze
                 systems containing mobile components",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "2",
  pages =        "167--198",
  month =        apr,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-2/p167-ciancarini/p167-ciancarini.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-2/p167-ciancarini/",
  abstract =     "New computing paradigms for network-aware applications
                 need specification languages able to deal with the
                 features of mobile code-based systems. A coordination
                 language provides a formal framework in which the
                 interaction of active entities can be expressed. A
                 coordination language deals with the creation and
                 destruction of code or complex agents, their
                 communication activities, as well as their distribution
                 and mobility in space. We show how the coordination
                 language PoliS offers a flexible basis for the
                 description and the automatic analysis of architectures
                 of systems including mobile entities. Polis is based on
                 multiple tuple spaces and offers a basis for defining,
                 studying, and controlling mobility as it allows
                 decoupling mobile entities from their environments both
                 in space and in time. The pattern-matching mechanism
                 adopted for communication helps in abstracting from
                 addressing issues. We have developed a model-checking
                 technique for the automatic analysis of PoliS
                 specifications. In the article we show how this
                 technique can be applied to mobile code-based systems",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Software Engineering --- Software/Program Verification
                 (D.2.4): {\bf Model checking}; Software --- Programming
                 Languages --- Formal Definitions and Theory (D.3.1):
                 {\bf Semantics}; Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Concurrent,
                 distributed, and parallel languages}",
}

@Article{Louridas:2000:GMR,
  author =       "Panagiotis Louridas and Pericles Loucopoulos",
  title =        "A generic model for reflective design",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "2",
  pages =        "199--237",
  month =        apr,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-2/p199-louridas/p199-louridas.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-2/p199-louridas/",
  abstract =     "Rapid technological change has had an impact on the
                 nature of software. This has led to new exigencies and
                 to demands for software engineering that pay particular
                 attention to meeting them. We advocate that such
                 demands can be met, at least in large parts, through
                 the adoption of software engineering processes that are
                 founded on a reflective stance. To this end, we turn
                 our attention to the field of Design Rationale. We
                 analyze and characterize Design Rationale approaches
                 and show that despite surface differences between
                 different approaches, they all tend to be variants of a
                 relatively small set of static and dynamic affinities.
                 We use the synthesis of static and dynamic affinities
                 to develop a generic model for reflective design. The
                 model is nonprescriptive and affects minimally the
                 design process. It is context-independent and is
                 intended to be used as a facilitator in participative
                 design, supporting group communication and
                 deliberation. The potential utility of the model is
                 demonstrated through two examples, one from the world
                 of business design and the other from programming
                 language design",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "design aids; design rationale; development;
                 participative; reflective",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Elicitation
                 methods (e.g., rapid prototyping, interviews, JAD)};
                 Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2)",
}

@Article{Inverardi:2000:SCS,
  author =       "Paola Inverardi and Alexander L. Wolf and Daniel
                 Yankelevich",
  title =        "Static checking of system behaviors using derived
                 component assumptions",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "3",
  pages =        "239--272",
  month =        jul,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-3/p239-inverardi/p239-inverardi.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-3/p239-inverardi/",
  abstract =     "A critical challenge faced by the developer of a
                 software system is to understand whether the system's
                 components correctly integrate. While type theory has
                 provided substantial help in detecting and preventing
                 errors in mismatched static properties, much work
                 remains in the area of dynamics. In particular,
                 components make assumptions about their behavioral
                 interaction with other components, but currently we
                 have only limited ways in which to state those
                 assumptions and to analyze those assumptions for
                 correctness. We have formulated a method that begins to
                 address this problem. The method operates at the
                 architectural level so that behavioral integration
                 errors, such as deadlock, can be revealed early and at
                 a high level. For each component, a specification is
                 given of its interaction behavior. Form this
                 specification, assumptions that the component makes
                 about the corresponding interaction behavior of the
                 external context are automatically derived. We have
                 defined an algorithm that performs compatibility checks
                 between finite representations of a component's context
                 assumptions and the actual interaction behaviors of the
                 components with which it is intended to interact. A
                 configuration of a system is possible if and only if a
                 successful way of matching actual behaviors with
                 assumptions can be found. The state-space complexity of
                 this algorithm is significantly less than that of
                 comparable approaches, and in the worst case, the time
                 complexity is comparable to the worst case of standard
                 reachability analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Theory; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "assumptions; chemical abstract machine model;
                 component-based systems; static analysis",
  subject =      "Software --- Software Engineering (D.2); Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2): {\bf Modules and interfaces}; Software ---
                 Software Engineering --- Design Tools and Techniques
                 (D.2.2): {\bf State diagrams}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Assertion checkers}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Formal methods}; Software --- Software Engineering
                 --- Software Architectures (D.2.11): {\bf Languages
                 (e.g., description, interconnection, definition)};
                 Theory of Computation --- Logics and Meanings of
                 Programs (F.3); Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1): {\bf Assertions};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Mechanical verification};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Specification
                 techniques}",
}

@Article{Minsky:2000:LGI,
  author =       "Naftaly H. Minsky and Victoria Ungureanu",
  title =        "Law-governed interaction: a coordination and control
                 mechanism for heterogeneous distributed systems",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "3",
  pages =        "273--305",
  month =        jul,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-3/p273-minsky/p273-minsky.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-3/p273-minsky/",
  abstract =     "Software technology is undergoing a transition form
                 monolithic systems, constructed according to a single
                 overall design, into conglomerates of semiautonomous,
                 heterogeneous, and independently designed subsystems,
                 constructed and managed by different organizations,
                 with little, if any, knowledge of each other. Among the
                 problems inherent in such conglomerates, none is more
                 serious than the difficulty to {\em control\/} the
                 activities of the disparate agents operating in it, and
                 the difficulty for such agents to {\em coordinate\/}
                 their activities with each other. We argue that the
                 nature of coordination and control required for such
                 systems calls for the following principles to be
                 satisfied: (1) coordination policies need to be
                 enforced: (2) the enforcement needs to be
                 decentralized; and (3) coordination policies need to be
                 formulated explicitly--rather than being implicit in
                 the code of the agents involved--and they should be
                 enforced by means of a generic, broad spectrum
                 mechanism; and (4) it should be possible to deploy and
                 enforce a policy incrementally, without exacting any
                 cost from agents and activities not subject to it. We
                 describe a mechanism called law-governed interaction
                 (LGI), currently implemented by the Moses toolkit,
                 which has been designed to satisfy these principles. We
                 show that LGI is at least as general as a conventional
                 centralized coordination mechanism (CCM), and that it
                 is more scalable, and generally more efficient, then
                 CCM.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Performance; Security",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "coordination of heterogeneous agents; policy
                 enforcement; scalability",
  subject =      "Software --- Software Engineering --- Software
                 Architectures (D.2.11); Software --- Software
                 Engineering --- Design Tools and Techniques (D.2.2);
                 Computer Systems Organization ---
                 Computer-Communication Networks --- Distributed Systems
                 (C.2.4); Information Systems --- Information Interfaces
                 and Presentation --- Group and Organization Interfaces
                 (H.5.3); Computer Applications --- Computers in Other
                 Systems (J.7): {\bf Command and control}",
}

@Article{Mills:2000:KBM,
  author =       "Kevin L. Mills and Hassan Gomaa",
  title =        "A knowledge-based method for inferring semantic
                 concepts from visual models of system behavior",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "3",
  pages =        "306--337",
  month =        jul,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-3/p306-mills/p306-mills.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-3/p306-mills/",
  abstract =     "Software designers use visual models, such as data
                 flow/control flow diagrams or object collaboration
                 diagrams, to express system behavior in a form that can
                 be understood easily by users and by programmers, and
                 from which designers can generate a software
                 architecture. The research described in this paper is
                 motivated by a desire to provide an automated
                 designer's assistant that can generate software
                 architectures for concurrent systems directly from
                 behavioral models expressed visually as flow diagrams.
                 To achieve this goal, an automated designer's assistant
                 must be capable of interpreting flow diagrams in
                 semantic, rather than syntactic, terms. While semantic
                 concepts can be attached manually to diagrams using
                 labels, such as stereotypes in the Unified Model
                 Language (UML), this paper considers the possibility of
                 providing automated assistance to infer appropriate
                 tags for symbols on a flow diagram. The approach relies
                 upon constructing an underlying metamodel that defines
                 semantic concepts based upon (1) syntactic
                 relationships among visual symbols and (2) inheritance
                 relationships among semantic concepts. Given such a
                 metamodel, a rule-based inference engine can, in many
                 situations, infer the presence of semantic concepts on
                 flow diagram, and can tag symbols accordingly. Futher,
                 an object-oriented query system can compare semantic
                 tags on digram instances for conformance with their
                 definition in the metamodel. To illustrate the
                 approach, the paper describes a metamodel for data
                 flow/control flow diagrams used in the context of a
                 specific software modeling method, Concurrent
                 Object-Based Real-time Analysis (COBRA). The metamodel
                 is implemented using an expert-system shell, CLIPS
                 V6.0, which integrates an object-oriented language with
                 a rule-based inference engine. \par

                 The paper applies the implemented metamodel to design
                 software for an automobile cruise-control system and
                 provides an evaluation of the approach based upon
                 results from four case studies. For the case studies,
                 the implemented metamodel recognized, automatically and
                 correctly, the existence of 86\% of all COBRA semantic
                 concepts within the flow diagrams. Varying degrees of
                 human assistance were used to correctly identify the
                 remaining semantic concepts within the diagrams: in two
                 percent of the cases the implemented metamodel reached
                 tentative classifications that a designer was asked to
                 confirm or override; in four percent of the cases a
                 designer was asked to provide additional information
                 before a concept was classified; in the remaining eight
                 percent of the cases the designer was asked to identify
                 the concept.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Experimentation; Measurement",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concept classification systems; concurrent systems;
                 knowledge-based software engineering; semantic data
                 modeling; software design methods; visual modeling",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2)",
}

@Article{Wallach:2000:SSM,
  author =       "Dan S. Wallach and Andrew W. Appel and Edward W.
                 Felten",
  title =        "{SAFKASI}: a security mechanism for language-based
                 systems",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "4",
  pages =        "341--378",
  month =        oct,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-4/p341-wallach/p341-wallach.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-4/p341-wallach/",
  abstract =     "In order to run untrusted code in the same process as
                 trusted code, there must be a mechanism to allow
                 dangerous calls to determine if their caller is
                 authorized to exercise the privilege of using the
                 dangerous routine. Java systems have adopted a
                 technique called stack inspection to address this
                 concern. But its original definition, in terms of
                 searching stack frames, had an unclear relationship to
                 the actual achievement of security, overconstrained the
                 implementation of a Java system, limited many desirable
                 optimizations such as method inlining and tail
                 recursion, and generally interfered with
                 interprocedural optimization. We present a new
                 semantics for stack inspection based on a belief logic
                 and its implementation using the calculus of {\em
                 security-passing style\/} which addresses the concerns
                 of traditional stack inspection. With security-passing
                 style, we can efficiently represent the security
                 context for any method activation, and we can build a
                 new implementation strictly by rewriting the Java
                 bytecodes before they are loaded by the system. No
                 changes to the JVM or bytecode semantics are necessary.
                 With a combination of static analysis and runtime
                 optimizations, our prototype implementation shows
                 reasonable performance (although traditional stack
                 inspection is still faster), and is easier to consider
                 for languages beyond Java. We call our system SAFKASI
                 (the Security Architecture Formerly Known as Stack
                 Inspection).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Security",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "access control; applets; Internet; Java;
                 security-passing style; stack inspection; WWW",
  subject =      "Software --- Programming Techniques ---
                 Object-oriented Programming (D.1.5); Software ---
                 Software Engineering --- General (D.2.0): {\bf
                 Protection mechanisms}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Object-oriented languages}; Software --- Operating
                 Systems --- Security and Protection (D.4.6): {\bf
                 Access controls}; Software --- Operating Systems ---
                 Security and Protection (D.4.6): {\bf Authentication}",
}

@Article{Fong:2000:PLM,
  author =       "Philip W. L. Fong and Robert D. Cameron",
  title =        "Proof linking: modular verification of mobile programs
                 in the presence of lazy, dynamic linking",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "4",
  pages =        "379--409",
  month =        oct,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-4/p379-fong/p379-fong.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-4/p379-fong/",
  abstract =     "Although mobile code systems typically employ
                 link-time code verifiers to protect host computers from
                 potentially malicious code, implementation flaws in the
                 verifiers may still leave the host system vulnerable to
                 attack. Compounding the inherent complexity of the
                 verification algorithms themselves, the need to support
                 lazy, dynamic linking in mobile code systems typically
                 leads to architectures that exhibit strong
                 interdependencies between the loader, the verifier, and
                 the linker. To simplify verifier construction and
                 provide improved assurances of verifier integrity, we
                 propose a modular architecture based on the concept of
                 proof linking. This architecture encapsulates the
                 verification process and removes dependencies between
                 the loader, the verifier, and the linker. We also
                 formally model the process of proof linking and
                 establish properties to which correct implementations
                 must conform. As an example, we instantiate our
                 architecture for the problem of Java bytecode
                 verification and assess the correctness of this
                 instantiation. Finally, we briefly discuss alternative
                 mobile code verification architectures enabled by the
                 proof-linking concept.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Design; Languages; Security; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "correctness conditions; dynamic linking; Java; mobile
                 code; modularity; proof linking; safety; verification
                 protocol; virtual machine architecture",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Correctness proofs};
                 Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Formal methods}; Software
                 --- Software Engineering ---
                 Requirements/Specifications (D.2.1); Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Run-time environments}",
}

@Article{Myers:2000:PPU,
  author =       "Andrew C. Myers and Barbara Liskov",
  title =        "Protecting privacy using the decentralized label
                 model",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "4",
  pages =        "410--442",
  month =        oct,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-4/p410-myers/p410-myers.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-4/p410-myers/",
  abstract =     "Stronger protection is needed for the confidentiality
                 and integrity of data, because programs containing
                 untrusted code are the rule rather than the exception.
                 Information flow control allows the enforcement of
                 end-to-end security policies, but has been difficult to
                 put into practice. This article describes the
                 decentralized label model, a new label model for
                 control of information flow in systems with mutual
                 distrust and decentralized authority. The model
                 improves on existing multilevel security models by
                 allowing users to declassify information in a
                 decentralized way, and by improving support for
                 fine-grained data sharing. It supports static program
                 analysis of information flow, so that programs can be
                 certified to permit only acceptable information flows,
                 while largely avoiding the overhead of run-time
                 checking. The article introduces the language Jif, an
                 extension to Java that provides static checking of
                 information flow using the decentralized label model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Security",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "confidentiality; declassification; downgrading;
                 end-to-end; information flow controls; integrity;
                 lattice; policies; principals; roles; type checking",
  subject =      "Software --- Operating Systems --- Security and
                 Protection (D.4.6): {\bf Information flow controls}",
}

@Article{Clarke:2000:VSP,
  author =       "E. M. Clarke and S. Jha and W. Marrero",
  title =        "Verifying security protocols with {Brutus}",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "4",
  pages =        "443--487",
  month =        oct,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-4/p443-clarke/p443-clarke.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-4/p443-clarke/",
  abstract =     "Due to the rapid growth of the ``Internet'' and the
                 ``World Wide Web'' security has become a very important
                 concern in the design and implementation of software
                 systems. Since security has become an important issue,
                 the number of protocols in this domain has become very
                 large. These protocols are very diverse in nature. If a
                 software architect wants to deploy some of these
                 protocols in a system, they have to be sure that the
                 protocol has the right properties as dictated by the
                 requirements of the system. In this article we present
                 BRUTUS, a tool for verifying properties of security
                 protocols. This tool can be viewed as a special-purpose
                 model checker for security protocols. We also present
                 reduction techniques that make the tool efficient.
                 Experimental results are provided to demonstrate the
                 efficiency of BRUTUS.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Security; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "authentication and secure payment protocols; formal
                 methods; model-checking",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4): {\bf Model checking}; Software
                 --- Operating Systems --- Security and Protection
                 (D.4.6): {\bf Verification**}",
}

@Article{Durante:2000:CAC,
  author =       "Antonio Durante and Riccardo Focardi and Roberto
                 Gorrieri",
  title =        "A compiler for analyzing cryptographic protocols using
                 noninterference",
  journal =      j-TOSEM,
  volume =       "9",
  number =       "4",
  pages =        "488--528",
  month =        oct,
  year =         "2000",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2000-9-4/p488-durante/p488-durante.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2000-9-4/p488-durante/",
  abstract =     "The Security Process Algebra (SPA) is a CCS-like
                 specification language where actions belong to two
                 different levels of confidentiality. It has been used
                 to define several noninterference-like security
                 properties whose verification has been automated by the
                 tool CoSeC. In recent years, a method for analyzing
                 security protocols using SPA and CoSeC has been
                 developed. Even if it has been useful in analyzing
                 small security protocols, this method has shown to be
                 error-prone, as it requires the protocol description
                 and its environment to be written by hand. This problem
                 has been solved by defining a protocol specification
                 language more abstract than SPA, called VSP, and a
                 compiler CVS that automatically generates the SPA
                 specification for a given protocol described in VSP.
                 The VSP/CVS technology is very powerful, and its
                 usefulness is shown with some case studies: the Woo-Lam
                 one-way authentication protocol, for which a new attack
                 to authentication is found, and the Wide Mouthed Frog
                 protocol, where different kinds of attack are detected
                 and analyzed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Security; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automatic verification; cryptographic protocols;
                 noninterference; process algebra; verification tool",
  subject =      "Computer Systems Organization ---
                 Computer-Communication Networks --- General (C.2.0):
                 {\bf Security and protection (e.g., firewalls)};
                 Computer Systems Organization ---
                 Computer-Communication Networks --- Network Protocols
                 (C.2.2): {\bf Protocol verification}; Software ---
                 Software Engineering --- Software/Program Verification
                 (D.2.4): {\bf Formal methods}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Model checking}; Software --- Software Engineering
                 --- Software/Program Verification (D.2.4): {\bf
                 Validation}; Theory of Computation --- Logics and
                 Meanings of Programs --- Semantics of Programming
                 Languages (F.3.2): {\bf Operational semantics}; Theory
                 of Computation --- Logics and Meanings of Programs ---
                 Semantics of Programming Languages (F.3.2): {\bf
                 Process models}",
}

@Article{Tip:2001:SBA,
  author =       "F. Tip and T. B. Dinesh",
  title =        "A slicing-based approach for locating type errors",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "1",
  pages =        "5--55",
  month =        jan,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-1/p5-tip/p5-tip.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-1/p5-tip/",
  abstract =     "The effectiveness of a type-checking tool strongly
                 depends on the accuracy of the positional information
                 that is associated with type errors. We present an
                 approach where the location associated with an error
                 message {\em e\/} is defined as a {\em slice\/} {\em P
                 e\/} of the program {\em P\/} being type-checked. We
                 show that this approach yields highly accurate
                 positional information: {\em P e\/} is a program that
                 contains precisely those program constructs in {\em
                 P\/} that caused error {\em e}. Semantically, we have
                 the interesting property that type-checking {\em P e\/}
                 is guaranteed to produce the same error {\em e}. Our
                 approach is completely language-independent and has
                 been implemented for a significant subset of Pascal. We
                 also report on experiments with object-oriented type
                 systems, and with a subset of ML.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "abstract interpretation; program slicing;
                 semantics-based tool generation; static semantics;
                 type-checking",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Translator writing systems and compiler
                 generators}; Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1): {\bf Specification
                 techniques}",
}

@Article{Chen:2001:TMO,
  author =       "Huo Yan Chen and T. H. Tse and T. Y. Chen",
  title =        "{TACCLE}: a methodology for object-oriented software
                 testing at the class and cluster levels",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "1",
  pages =        "56--109",
  month =        jan,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-1/p56-chen/p56-chen.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-1/p56-chen/",
  abstract =     "Object-oriented programming consists of several
                 different levels of abstraction, namely, the
                 algorithmic level, class level, cluster level, and
                 system level. The testing of object-oriented software
                 at the algorithmic and system levels is similar to
                 conventional program testing. Testing at the class and
                 cluster levels poses new challenges. Since methods and
                 objects may interact with one another with unforeseen
                 combinations and invocations, they are much more
                 complex to simulate and test than the hierarchy of
                 functional calls in conventional programs. In this
                 paper, we propose a methodology for object-oriented
                 software testing at the class and cluster levels. In
                 class-level testing, it is essential to determine
                 whether objects produced from the execution of
                 implemented systems would preserve the properties
                 defined by the specification, such as behavioral
                 equivalence and nonequivalence. Our class-level testing
                 methodology addresses both of these aspects. For the
                 testing of behavioral equivalence, we propose to select
                 fundamental pairs of equivalent ground terms as test
                 cases using a black-box technique based on algebraic
                 specifications, and then determine by means of a
                 white-box technique whether the objects resulting from
                 executing such test cases are observationally
                 equivalent. To address the testing of behavioral
                 nonequivalence, we have identified and analyzed several
                 nontrivial problems in the current literature. We
                 propose to classify term equivalence into four types,
                 thereby setting up new concepts and deriving important
                 properties. Based on these results, we propose an
                 approach to deal with the problems in the generation of
                 nonequivalent ground terms as test cases. Relatively
                 little research has contributed to cluster-level
                 testing. In this paper, we also discuss black-box
                 testing at the cluster level. We illustrate the
                 feasibility of using contract, a formal specification
                 language for the behavioral dependencies and
                 interactions among cooperating objects of different
                 classes in a given cluster. We propose an approach to
                 test the interactions among different classes using
                 every individual message-passing rule in the given
                 Contract specification. We also present an approach to
                 examine the interactions among composite
                 message-passing sequences. We have developed four
                 testing tools to support our methodology.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Languages; Reliability",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "algebraic specifications; contact specifications;
                 message passing; object-oriented programming; software
                 testing",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1): {\bf Languages};
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}; Software ---
                 Programming Languages --- Language Classifications
                 (D.3.2): {\bf Object-oriented languages}",
}

@Article{Rothermel:2001:MTS,
  author =       "Gregg Rothermel and Margaret Burnett and Lixin Li and
                 Christopher Dupuis and Andrei Sheretov",
  title =        "A methodology for testing spreadsheets",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "1",
  pages =        "110--147",
  month =        jan,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-1/p110-rothermel/p110-rothermel.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-1/p110-rothermel/",
  abstract =     "Spreadsheet languages, which include commercial
                 spreadsheets and various research systems, have had a
                 substantial impact on end-user computing. Research
                 shows, however, that spreadsheets often contain faults;
                 thus, we would like to provide at least some of the
                 benefits of formal testing methodologies to the
                 creators of spreadsheets. This article presents a
                 testing methodology that adapts data flow adequacy
                 criteria and coverage monitoring to the task of testing
                 spreadsheets. To accommodate the evaluation model used
                 with spreadsheets, and the interactive process by which
                 they are created, our methodology is incremental. To
                 accommodate the users of spreadsheet languages, we
                 provide an interface to our methodology that does not
                 require an understanding of testing theory. We have
                 implemented our testing methodology in the context of
                 the Froms/3 visual spreadsheet language. We report on
                 the methodology, its time and space costs, and the
                 mapping from the testing strategy to the user
                 interfaces. In an empirical study, we found that test
                 suites created according to our methodology detected,
                 on average, 81\% of the faults in a set of faulty
                 spreadsheets, significantly outperforming randomly
                 generated test suites.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Languages; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "software testing; spreadsheets",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5); Software --- Software Engineering
                 --- Programming Environments (D.2.6); Information
                 Systems --- Information Systems Applications --- Office
                 Automation (H.4.1); Software --- Programming Techniques
                 --- Visual Programming (D.1.7)",
}

@Article{Bible:2001:CSC,
  author =       "John Bible and Gregg Rothermel and David S.
                 Rosenblum",
  title =        "A comparative study of coarse- and fine-grained safe
                 regression test-selection techniques",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "2",
  pages =        "149--183",
  month =        apr,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-2/p149-bible/p149-bible.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-2/p149-bible/",
  abstract =     "{\em Regression test-selection techniques\/} reduce
                 the cost of regression testing by selecting a subset of
                 an existing test suite to use in retesting a modified
                 program. Over the past two decades, numerous regression
                 test-selection techniques have been described in the
                 literature. Initial empirical studies of some of these
                 techniques have suggested that they can indeed benefit
                 testers, but so far, few studies have empirically
                 compared different techniques. In this paper, we
                 present the results of a comparative empirical study of
                 two safe regression test-selection techniques. The
                 techniques we studied have been implemented as the
                 tools DejaVu and TestTube; we compared these tools in
                 terms of a cost model incorporating {\em precision\/}
                 (ability to eliminate unnecessary test cases), {\em
                 analysis cost}, and {\em test execution cost}. Our
                 results indicate, that in many instances, despite its
                 relative lack of precision, TestTube can reduce the
                 time required for regression testing as much as the
                 more precise DejaVu. In other instances, particularly
                 where the time required to execute test cases is long,
                 DejaVu's superior precision gives it a clear advantage
                 over TestTube. Such variations in relative performance
                 can complicate a tester's choice of which tool to use.
                 Our experimental results suggest that a hybrid
                 regression test-selection tool that combines features
                 of TestTube and DejaVu may be an answer to these
                 complications; we present an initial case study that
                 demonstrates the potential benefit of such a tool.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Verification",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "regression test selection; regression testing",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5)",
}

@Article{Graves:2001:ESR,
  author =       "Todd L. Graves and Mary Jean Harrold and Jung-Min Kim
                 and Adam Porter and Gregg Rothermel",
  title =        "An empirical study of regression test selection
                 techniques",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "2",
  pages =        "184--208",
  month =        apr,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-2/p184-graves/p184-graves.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-2/p184-graves/",
  abstract =     "Regression testing is the process of validating
                 modified software to detect whether new errors have
                 been introduced into previously tested code and to
                 provide confidence that modifications are correct.
                 Since regression testing is an expensive process,
                 researchers have proposed regression test selection
                 techniques as a way to reduce some of this expense.
                 These techniques attempt to reduce costs by selecting
                 and running only a subset of the test cases in a
                 program's existing test suite. Although there have been
                 some analytical and empirical evaluations of individual
                 techniques, to our knowledge only one comparative
                 study, focusing on one aspect of two of these
                 techniques, has been reported in the literature. We
                 conducted an experiment to examine the relative costs
                 and benefits of several regression test selection
                 techniques. The experiment examined five techniques for
                 reusing test cases, focusing on their relative
                 abilities to reduce regression testing effort and
                 uncover faults in modified programs. Our results
                 highlight several differences between the techniques,
                 and expose essential trade-offs that should be
                 considered when choosing a technique for practical
                 application.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "empirical study; regression testing; selective
                 retest",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}; Software --- Software
                 Engineering --- Testing and Debugging (D.2.5): {\bf
                 Debugging aids}",
}

@Article{Sinha:2001:ICD,
  author =       "Saurabh Sinha and Mary Jean Harrold and Gregg
                 Rothermel",
  title =        "Interprocedural control dependence",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "2",
  pages =        "209--254",
  month =        apr,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Apr 20 08:21:35 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/tosem/2001-10-2/p209-sinha/p209-sinha.pdf;
                 http://www.acm.org/pubs/citations/journals/tosem/2001-10-2/p209-sinha/",
  abstract =     "Program-dependence information is useful for a variety
                 of applications, such as software testing and
                 maintenance tasks, and code optimization. Properly
                 defined, control and data dependences can be used to
                 identify semantic dependences. To function effectively
                 on whole programs, tools that utilize dependence
                 information require information about interprocedural
                 dependences: dependences that are identified by
                 analyzing the interactions among procedures. Many
                 techniques for computing interprocedural data
                 dependences exist; however, virtually no attention has
                 been paid to interprocedural control dependence.
                 Analysis techniques that fail to account for
                 interprocedural control dependences can suffer
                 unnecessary imprecision and loss of safety. This
                 article presents a definition of interprocedural
                 control dependence that supports the relationship of
                 control and data dependence to semantic dependence. The
                 article presents two approaches for computing
                 interprocedural control dependences, and empirical
                 results pertaining to the use of those approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  generalterms = "Algorithms; Languages; Theory",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "interprocedural analysis; interprocedural control
                 dependence; program slicing; semantic dependence;
                 software maintenance",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Debugging aids}; Software ---
                 Software Engineering --- Distribution, Maintenance, and
                 Enhancement (D.2.7): {\bf Restructuring, reverse
                 engineering, and reengineering}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Control structures}; Software
                 --- Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}; Computing
                 Methodologies --- Symbolic and Algebraic Manipulation
                 --- Algorithms (I.1.2): {\bf Analysis of algorithms};
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Testing tools (e.g., data
                 generators, coverage testing)}",
}

@Article{Gargantini:2001:ADR,
  author =       "Angelo Gargantini and Angelo Morzenti",
  title =        "Automated deductive requirements analysis of critical
                 systems",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "3",
  pages =        "255--307",
  month =        jul,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Perry:2001:PCL,
  author =       "Dewayne E. Perry and Harvey P. Siy and Lawrence G.
                 Votta",
  title =        "Parallel changes in large-scale software development:
                 an observational case study",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "3",
  pages =        "308--337",
  month =        jul,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Picco:2001:RAC,
  author =       "Gian Pietro Picco and Gruia-Catalin Roman and Peter J.
                 McCann",
  title =        "Reasoning about code mobility with mobile {UNITY}",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "3",
  pages =        "338--395",
  month =        jul,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Beauvais:2001:MSA,
  author =       "J.-R. Beauvais and E. Rutten and T. Gautier and R.
                 Houdebine and P. Le Guernic and Y.-M. Tang",
  title =        "Modeling statecharts and activitycharts as signal
                 equations",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "4",
  pages =        "397--451",
  month =        oct,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bonifati:2001:DDM,
  author =       "Angela Bonifati and Fabiano Cattaneo and Stefano Ceri
                 and Alfonso Fuggetta and Stefano Paraboschi",
  title =        "Designing data marts for data warehouses",
  journal =      j-TOSEM,
  volume =       "10",
  number =       "4",
  pages =        "452--483",
  month =        oct,
  year =         "2001",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Medvidovic:2002:MSA,
  author =       "Nenad Medvidovic and David S. Rosenblum and David F.
                 Redmiles and Jason E. Robbins",
  title =        "Modeling software architectures in the {Unified
                 Modeling Language}",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "1",
  pages =        "2--57",
  month =        jan,
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tsuchiya:2002:FCE,
  author =       "Tatsuhiro Tsuchiya and Tohru Kikuno",
  title =        "On fault classes and error detection capability of
                 specification-based testing",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "1",
  pages =        "58--62",
  month =        jan,
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Keidar:2002:IBT,
  author =       "Idit Keidar and Roger Khazan and Nancy Lynch and Alex
                 Shvartsman",
  title =        "An inheritance-based technique for building simulation
                 proofs incrementally",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "1",
  pages =        "63--91",
  month =        jan,
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Schrefl:2002:BCS,
  author =       "Michael Schrefl and Markus Stumptner",
  title =        "Behavior-consistent specialization of object life
                 cycles",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "1",
  pages =        "92--148",
  month =        jan,
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Feb 19 14:55:16 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Felder:2002:FDN,
  author =       "Miguel Felder and Mauro Pezz{\`e}",
  title =        "A formal design notation for real-time systems",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "2",
  pages =        "149--190",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Batory:2002:AET,
  author =       "Don Batory and Clay Johnson and Bob Macdonald and Dale
                 Von Heeder",
  title =        "Achieving extensibility through product-lines and
                 domain-specific languages: a case study",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "2",
  pages =        "191--214",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Smaragdakis:2002:MLO,
  author =       "Yannis Smaragdakis and Don Batory",
  title =        "Mixin layers: an object-oriented implementation
                 technique for refinements and collaboration-based
                 designs",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "2",
  pages =        "215--255",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jackson:2002:ALO,
  author =       "Daniel Jackson",
  title =        "{Alloy}: a lightweight object modelling notation",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "2",
  pages =        "256--290",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pons:2002:TAC,
  author =       "Alexander P. Pons",
  title =        "Temporal abstract classes and virtual temporal
                 specifications for real-time systems",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "3",
  pages =        "291--308",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mockus:2002:TCS,
  author =       "Audris Mockus and Roy T. Fielding and James D.
                 Herbsleb",
  title =        "Two case studies of open source software development:
                 {Apache} and {Mozilla}",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "3",
  pages =        "309--346",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liang:2002:EAA,
  author =       "Donglin Liang and Mary Jean Harrold",
  title =        "Equivalence analysis and its application in improving
                 the efficiency of program slicing",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "3",
  pages =        "347--383",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:17 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Anonymous:2002:OOJ,
  author =       "Anonymous",
  title =        "Obituary: {Ole-Johan Dahl, 1931--2002; Edsger Wybe
                 Dijkstra, 1930--2002; Kristen Nygaard, 1926--2002}",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "4",
  pages =        "385--385",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bernardo:2002:AFS,
  author =       "Marco Bernardo and Paolo Ciancarini and Lorenzo
                 Donatiello",
  title =        "Architecting families of software systems with process
                 algebras",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "4",
  pages =        "386--426",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2002:CTS,
  author =       "R. M. Hierons",
  title =        "Comparing test sets and criteria in the presence of
                 test hypotheses and fault domains",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "4",
  pages =        "427--448",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Egyed:2002:AAC,
  author =       "Alexander Egyed",
  title =        "Automated abstraction of class diagrams",
  journal =      j-TOSEM,
  volume =       "11",
  number =       "4",
  pages =        "449--491",
  year =         "2002",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ghezzi:2003:E,
  author =       "Carlo Ghezzi and Jeffrey N. Magee and Dieter Rombach
                 and Mary Lou Soffa",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "1",
  pages =        "1--2",
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Felty:2003:FSA,
  author =       "Amy P. Felty and Kedar S. Namjoshi",
  title =        "Feature specification and automated conflict
                 detection",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "1",
  pages =        "3--27",
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nentwich:2003:FCC,
  author =       "Christian Nentwich and Wolfgang Emmerich and Anthony
                 Finkelstein and Ernst Ellmer",
  title =        "Flexible consistency checking",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "1",
  pages =        "28--63",
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lopes:2003:HOA,
  author =       "Ant{\'o}nia Lopes and Michel Wermelinger and Jos{\'e}
                 Luiz Fiadeiro",
  title =        "Higher-order architectural connectors",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "1",
  pages =        "64--104",
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Staff:2003:R,
  author =       "{ACM Transactions on Software Engineering and
                 Methodology staff}",
  title =        "Reviewers 2002",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "1",
  pages =        "105--105",
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Aug 7 10:57:18 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Coen-Porisini:2003:FAD,
  author =       "Alberto Coen-Porisini and Matteo Pradella and Matteo
                 Rossi and Dino Mandrioli",
  title =        "A formal approach for designing {CORBA}-based
                 applications",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "2",
  pages =        "107--151",
  month =        apr,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 31 06:06:37 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{VanDenBrand:2003:TRT,
  author =       "Mark G. J. {Van Den Brand} and Paul Klint and Jurgen
                 J. Vinju",
  title =        "Term rewriting with traversal functions",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "2",
  pages =        "152--190",
  month =        apr,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 31 06:06:37 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Robillard:2003:SAS,
  author =       "Martin P. Robillard and Gail C. Murphy",
  title =        "Static analysis to support the evolution of exception
                 structure in object-oriented systems",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "2",
  pages =        "191--221",
  month =        apr,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 31 06:06:37 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Durante:2003:ATE,
  author =       "Luca Durante and Riccardo Sisto and Adriano
                 Valenzano",
  title =        "Automatic testing equivalence verification of spi
                 calculus specifications",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "2",
  pages =        "222--284",
  month =        apr,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 31 06:06:37 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cohen:2003:AHQ,
  author =       "Yossi Cohen and Yishai A. Feldman",
  title =        "Automatic high-quality reengineering of database
                 programs by abstraction, transformation and
                 reimplementation",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "3",
  pages =        "285--316",
  month =        jul,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Dec 13 18:40:57 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zambonelli:2003:DMS,
  author =       "Franco Zambonelli and Nicholas R. Jennings and Michael
                 Wooldridge",
  title =        "Developing multiagent systems: {The Gaia}
                 methodology",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "3",
  pages =        "317--370",
  month =        jul,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Dec 13 18:40:57 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chechik:2003:MVS,
  author =       "Marsha Chechik and Benet Devereux and Steve
                 Easterbrook and Arie Gurfinkel",
  title =        "Multi-valued symbolic model-checking",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "4",
  pages =        "371--408",
  month =        oct,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Miller:2003:FTS,
  author =       "Tim Miller and Paul Strooper",
  title =        "A framework and tool support for the systematic
                 testing of model-based specifications",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "4",
  pages =        "409--439",
  month =        oct,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ferrari:2003:MCV,
  author =       "Gian-Luigi Ferrari and Stefania Gnesi and Ugo
                 Montanari and Marco Pistore",
  title =        "A model-checking verification environment for mobile
                 processes",
  journal =      j-TOSEM,
  volume =       "12",
  number =       "4",
  pages =        "440--473",
  month =        oct,
  year =         "2003",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zave:2004:ATT,
  author =       "Pamela Zave",
  title =        "Address translation in telecommunication features",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "1",
  pages =        "1--36",
  month =        jan,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Uchitel:2004:IES,
  author =       "Sebastian Uchitel and Jeff Kramer and Jeff Magee",
  title =        "Incremental elaboration of scenario-based
                 specifications and behavior models using implied
                 scenarios",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "1",
  pages =        "37--85",
  month =        jan,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Venkatasubramanian:2004:FMR,
  author =       "Nalini Venkatasubramanian and Carolyn Talcott and Gul
                 A. Agha",
  title =        "A formal model for reasoning about adaptive
                 {QoS}-enabled middleware",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "1",
  pages =        "86--147",
  month =        jan,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Akgul:2004:AIL,
  author =       "Tankut Akgul and Vincent J. {Mooney III}",
  title =        "Assembly instruction level reverse execution for
                 debugging",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "2",
  pages =        "149--198",
  month =        apr,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Orso:2004:CDD,
  author =       "Alessandro Orso and Saurabh Sinha and Mary Jean
                 Harrold",
  title =        "Classifying data dependences in the presence of
                 pointers for program comprehension, testing, and
                 debugging",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "2",
  pages =        "199--239",
  month =        apr,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Roshandel:2004:MSM,
  author =       "Roshanak Roshandel and Andr{\'e} {Van Der Hoek} and
                 Marija Mikic-Rakic and Nenad Medvidovic",
  title =        "{Mae}---a system model and environment for managing
                 architectural evolution",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "2",
  pages =        "240--276",
  month =        apr,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rothermel:2004:TSC,
  author =       "Gregg Rothermel and Sebastian Elbaum and Alexey G.
                 Malishevsky and Praveen Kallakuri and Xuemei Qiu",
  title =        "On test suite composition and cost-effective
                 regression testing",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "3",
  pages =        "277--331",
  month =        jul,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kramer:2004:CCM,
  author =       "Stefan Kramer and Hermann Kaindl",
  title =        "Coupling and cohesion metrics for knowledge-based
                 systems using frames and rules",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "3",
  pages =        "332--358",
  month =        jul,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Nov 4 07:55:52 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dwyer:2004:FAV,
  author =       "Matthew B. Dwyer and Lori A. Clarke and Jamieson M.
                 Cobleigh and Gleb Naumovich",
  title =        "Flow analysis for verifying properties of concurrent
                 software systems",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "4",
  pages =        "359--430",
  month =        oct,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 14 10:42:21 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Costagliola:2004:FMI,
  author =       "Gennaro Costagliola and Vincenzo Deufemia and Giuseppe
                 Polese",
  title =        "A framework for modeling and implementing visual
                 notations with applications to software engineering",
  journal =      j-TOSEM,
  volume =       "13",
  number =       "4",
  pages =        "431--487",
  month =        oct,
  year =         "2004",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 14 10:42:21 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Milanova:2005:POS,
  author =       "Ana Milanova and Atanas Rountev and Barbara G. Ryder",
  title =        "Parameterized object sensitivity for points-to
                 analysis for {Java}",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "1",
  pages =        "1--41",
  month =        jan,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 14 10:42:22 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Baresi:2005:FID,
  author =       "Luciano Baresi and Mauro Pezz{\`e}",
  title =        "Formal interpreters for diagram notations",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "1",
  pages =        "42--84",
  month =        jan,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 14 10:42:22 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sommerville:2005:ESI,
  author =       "Ian Sommerville and Jane Ransom",
  title =        "An empirical study of industrial requirements
                 engineering process assessment and improvement",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "1",
  pages =        "85--117",
  month =        jan,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 14 10:42:22 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ghezzi:2005:E,
  author =       "Carlo Ghezzi",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "2",
  pages =        "119--123",
  month =        apr,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 2 11:17:01 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Berstel:2005:SFM,
  author =       "Jean Berstel and Stefano Crespi Reghizzi and Gilles
                 Roussel and Pierluigi San Pietro",
  title =        "A scalable formal method for design and automatic
                 checking of user interfaces",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "2",
  pages =        "124--167",
  month =        apr,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 2 11:17:01 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Erwig:2005:SRS,
  author =       "Martin Erwig and Zhe Fu",
  title =        "Software reuse for scientific computing through
                 program generation",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "2",
  pages =        "168--198",
  month =        apr,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 2 11:17:01 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dashofy:2005:CAD,
  author =       "Eric M. Dashofy and Andr{\'e} van der Hoek and Richard
                 N. Taylor",
  title =        "A comprehensive approach for the development of
                 modular software architecture description languages",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "2",
  pages =        "199--245",
  month =        apr,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 2 11:17:01 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Staff:2005:AR,
  author =       "{ACM Transactions on Software Engineering and
                 Methodology staff}",
  title =        "Acknowledgement of referees 2004",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "2",
  pages =        "246--246",
  month =        apr,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 2 11:17:01 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lau:2005:EFC,
  author =       "Man F. Lau and Yuen T. Yu",
  title =        "An extended fault class hierarchy for
                 specification-based testing",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "3",
  pages =        "247--276",
  month =        jul,
  year =         "2005",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1072997.1072998",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 23 15:50:12 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gervasi:2005:RAI,
  author =       "Vincenzo Gervasi and Didar Zowghi",
  title =        "Reasoning about inconsistencies in natural language
                 requirements",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "3",
  pages =        "277--330",
  month =        jul,
  year =         "2005",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1072997.1072999",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 23 15:50:12 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Klint:2005:TED,
  author =       "Paul Klint and Ralf L{\"a}mmel and Chris Verhoef",
  title =        "Toward an engineering discipline for grammarware",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "3",
  pages =        "331--380",
  month =        jul,
  year =         "2005",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1072997.1073000",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 23 15:50:12 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Osterweil:2005:E,
  author =       "Leon Osterweil and Carlo Ghezzi and Jeff Kramer and
                 Alexander Wolf",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "4",
  pages =        "381--382",
  month =        oct,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Nov 25 05:58:01 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Estublier:2005:ISE,
  author =       "Jacky Estublier and David Leblang and Andr{\'e} van
                 der Hoek and Reidar Conradi and Geoffrey Clemm and
                 Walter Tichy and Darcy Wiborg-Weber",
  title =        "Impact of software engineering research on the
                 practice of software configuration management",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "4",
  pages =        "383--430",
  month =        oct,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Nov 25 05:58:01 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ryder:2005:ISE,
  author =       "Barbara G. Ryder and Mary Lou Soffa and Margaret
                 Burnett",
  title =        "The impact of software engineering research on modern
                 programming languages",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "4",
  pages =        "431--477",
  month =        oct,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Nov 25 05:58:01 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Frias:2005:RAS,
  author =       "Marcelo F. Frias and Carlos G. L{\'o}pez Pombo and
                 Gabriel A. Baum and Nazareno M. Aguirre and Thomas S.
                 E. Maibaum",
  title =        "Reasoning about static and dynamic properties in
                 alloy: a purely relational approach",
  journal =      j-TOSEM,
  volume =       "14",
  number =       "4",
  pages =        "478--526",
  month =        oct,
  year =         "2005",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Nov 25 05:58:01 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Eshuis:2006:SMC,
  author =       "Rik Eshuis",
  title =        "Symbolic model checking of {UML} activity diagrams",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "1",
  pages =        "1--38",
  month =        jan,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1125808.1125809",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Apr 22 06:14:53 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Basin:2006:MDS,
  author =       "David Basin and J{\"u}rgen Doser and Torsten
                 Lodderstedt",
  title =        "Model driven security: {From UML} models to access
                 control infrastructures",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "1",
  pages =        "39--91",
  month =        jan,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1125808.1125810",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 04 08:41:19 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Snook:2006:UBF,
  author =       "Colin Snook and Michael Butler",
  title =        "{UML-B}: {Formal} modeling and design aided by {UML}",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "1",
  pages =        "92--122",
  month =        jan,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1125808.1125811",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Apr 22 06:14:53 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Counsell:2006:IUT,
  author =       "Steve Counsell and Stephen Swift and Jason Crampton",
  title =        "The interpretation and utility of three cohesion
                 metrics for object-oriented design",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "2",
  pages =        "123--149",
  month =        apr,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1131421.1131422",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri May 12 07:34:50 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fisher:2006:IAT,
  author =       "Marc {Fisher II} and Gregg Rothermel and Darren Brown
                 and Mingming Cao and Curtis Cook and Margaret Burnett",
  title =        "Integrating automated test generation into the
                 {WYSIWYT} spreadsheet testing methodology",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "2",
  pages =        "150--194",
  month =        apr,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1131421.1131423",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri May 12 07:34:50 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2006:STS,
  author =       "Wei Zhao and Lu Zhang and Yin Liu and Jiasu Sun and
                 Fuqing Yang",
  title =        "{SNIAFL}: {Towards} a static noninteractive approach
                 to feature location",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "2",
  pages =        "195--226",
  month =        apr,
  year =         "2006",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1131421.1131424",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri May 12 07:34:50 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2006:ACC,
  author =       "R. M. Hierons",
  title =        "Avoiding coincidental correctness in boundary value
                 analysis",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "3",
  pages =        "227--241",
  month =        jul,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 29 05:26:07 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sinha:2006:HMB,
  author =       "Avik Sinha and Carol Smidts",
  title =        "{HOTTest}: a model-based test design technique for
                 enhanced testing of domain-specific applications",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "3",
  pages =        "242--278",
  month =        jul,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 29 05:26:07 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Murphy:2006:LCM,
  author =       "Amy L. Murphy and Gian Pietro Picco and Gruia-Catalin
                 Roman",
  title =        "{LIME}: a coordination model and middleware supporting
                 mobility of hosts and agents",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "3",
  pages =        "279--328",
  month =        jul,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 29 05:26:07 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Thiran:2006:WBE,
  author =       "Philippe Thiran and Jean-Luc Hainaut and Geert-Jan
                 Houben and Djamal Benslimane",
  title =        "Wrapper-based evolution of legacy information
                 systems",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "4",
  pages =        "329--359",
  month =        oct,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 15 06:42:33 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Brambilla:2006:PMW,
  author =       "Marco Brambilla and Stefano Ceri and Piero Fraternali
                 and Ioana Manolescu",
  title =        "Process modeling in {Web} applications",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "4",
  pages =        "360--409",
  month =        oct,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 15 06:42:33 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Snelting:2006:EPC,
  author =       "Gregor Snelting and Torsten Robschink and Jens
                 Krinke",
  title =        "Efficient path conditions in dependence graphs for
                 software safety analysis",
  journal =      j-TOSEM,
  volume =       "15",
  number =       "4",
  pages =        "410--457",
  month =        oct,
  year =         "2006",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 15 06:42:33 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Notkin:2007:Ea,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1189748.1189749",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:11:50 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ghezzi:2007:E,
  author =       "Carlo Ghezzi",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "1",
  pages =        "2:1--2:??",
  month =        feb,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1189748.1189750",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:11:50 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Robillard:2007:RCS,
  author =       "Martin P. Robillard and Gail C. Murphy",
  title =        "Representing concerns in source code",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "1",
  pages =        "3:1--3:??",
  month =        feb,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1189748.1189751",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:11:50 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A software modification task often addresses several
                 concerns. A concern is anything a stakeholder may want
                 to consider as a conceptual unit, including features,
                 nonfunctional requirements, and design idioms. In many
                 cases, the source code implementing a concern is not
                 encapsulated in a single programming language module,
                 and is instead scattered and tangled throughout a
                 system. Inadequate separation of concerns increases the
                 difficulty of evolving software in a correct and
                 cost-effective manner. To make it easier to modify
                 concerns that are not well modularized, we propose an
                 approach in which the implementation of concerns is
                 documented in artifacts, called concern graphs. Concern
                 graphs are abstract models that describe which parts of
                 the source code are relevant to different concerns. We
                 present a formal model for concern graphs and the tool
                 support we developed to enable software developers to
                 create and use concern graphs during software evolution
                 tasks. We report on five empirical studies, providing
                 evidence that concern graphs support views and
                 operations that facilitate the task of modifying the
                 code implementing scattered concerns, are
                 cost-effective to create and use, and robust enough to
                 be used with different versions of a software system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "aspect-oriented software development; concern
                 modeling; Java; Separation of concerns; software
                 evolution",
}

@Article{Xie:2007:DCA,
  author =       "Qing Xie and Atif M. Memon",
  title =        "Designing and comparing automated test oracles for
                 {GUI}-based software applications",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "1",
  pages =        "4:1--4:??",
  month =        feb,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1189748.1189752",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:11:50 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Test designers widely believe that the overall
                 effectiveness and cost of software testing depends
                 largely on the type and number of test cases executed
                 on the software. This article shows that the test
                 oracle, a mechanism that determines whether a software
                 is executed correctly for a test case, also
                 significantly impacts the fault detection effectiveness
                 and cost of a test case. Graphical user interfaces
                 (GUIs), which have become ubiquitous for interacting
                 with today's software, have created new challenges for
                 test oracle development. Test designers manually
                 ``assert'' the expected values of specific properties
                 of certain GUI widgets in each test case; during test
                 execution, these assertions are used as test oracles to
                 determine whether the GUI executed correctly. Since a
                 test case for a GUI is a sequence of events, a test
                 designer must decide: (1) what to assert; and (2) how
                 frequently to check an assertion, for example, after
                 each event in the test case or after the entire test
                 case has completed execution. Variations of these two
                 factors significantly impact the fault-detection
                 ability and cost of a GUI test case. A technique to
                 declaratively specify different types of automated GUI
                 test oracles is described. Six instances of test
                 oracles are developed and compared in an experiment on
                 four software systems. The results show that test
                 oracles do affect the fault detection ability of test
                 cases in different and interesting ways: (1) Test cases
                 significantly lose their fault detection ability when
                 using ``weak'' test oracles; (2) in many cases,
                 invoking a ``thorough'' oracle at the end of test case
                 execution yields the best cost-benefit ratio; (3)
                 certain test cases detect faults only if the oracle is
                 invoked during a small ``window of opportunity'' during
                 test execution; and (4) using thorough and
                 frequently-executing test oracles can compensate for
                 not having long test cases.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "graphical user interfaces; GUI state; GUI testing;
                 Test oracles; user interfaces; widgets",
}

@Article{Broy:2007:FMS,
  author =       "Manfred Broy and Ingolf H. Kr{\"u}ger and Michael
                 Meisinger",
  title =        "A formal model of services",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "1",
  pages =        "5:1--5:??",
  month =        feb,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1189748.1189753",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:11:50 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Service-oriented software systems rapidly gain
                 importance across application domains: They emphasize
                 functionality (services), rather structural entities
                 (components), as the basic building block for system
                 composition. More specifically, services coordinate the
                 interplay of components to accomplish specific tasks.
                 In this article, we establish a foundation of service
                 orientation: Based on the Focus theory of distributed
                 systems (see Broy and St{\o}len [2001]), we introduce a
                 theory and formal model of services. In Focus, systems
                 are composed of interacting components. A component is
                 a total behavior. We introduce a formal model of
                 services where, in contrast, a service is a partial
                 behavior. For services and components, we work out
                 foundational specification techniques and outline
                 methodological development steps. We show how services
                 can be structured and how software architectures can be
                 composed of services and components. Although our
                 emphasis is on a theoretical foundation of the notion
                 of services, we demonstrate utility of the concepts we
                 introduce by means of a running example from the
                 automotive domain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "assumption/commitment specifications; Components;
                 service engineering; services; software architecture",
}

@Article{Notkin:2007:Eb,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "2",
  pages =        "6:1--6:??",
  month =        apr,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1217295.1237801",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Krishnamurthi:2007:FIA,
  author =       "Shriram Krishnamurthi and Kathi Fisler",
  title =        "Foundations of incremental aspect model-checking",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "2",
  pages =        "7:1--7:??",
  month =        apr,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1217295.1217296",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Programs are increasingly organized around features,
                 which are encapsulated using aspects and other
                 linguistic mechanisms. Despite their growing popularity
                 amongst developers, there is a dearth of techniques for
                 computer-aided verification of programs that employ
                 these mechanisms. We present the theoretical
                 underpinnings for applying model checking to programs
                 (expressed as state machines) written using these
                 mechanisms. The analysis is incremental, examining only
                 components that change rather than verifying the entire
                 system every time one part of it changes. Our technique
                 assumes that the set of pointcut designators is known
                 statically, but the actual advice can vary. It handles
                 both static and dynamic pointcut designators. We
                 present the algorithm, prove it sound, and address
                 several subtleties that arise, including cascading
                 advice application and problems of circular
                 reasoning.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "aspect-oriented programming; feature-oriented
                 software; Incremental verification; model checking;
                 modular verification",
}

@Article{Binkley:2007:ESS,
  author =       "David Binkley and Nicolas Gold and Mark Harman",
  title =        "An empirical study of static program slice size",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "2",
  pages =        "8:1--8:??",
  month =        apr,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1217295.1217297",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article presents results from a study of all
                 slices from 43 programs, ranging up to 136,000 lines of
                 code in size. The study investigates the effect of five
                 aspects that affect slice size. Three slicing
                 algorithms are used to study two algorithmic aspects:
                 calling-context treatment and slice granularity. The
                 remaining three aspects affect the upstream
                 dependencies considered by the slicer. These include
                 collapsing structure fields, removal of dead code, and
                 the influence of points-to analysis.\par

                 The results show that for the most precise slicer, the
                 average slice contains just under one-third of the
                 program. Furthermore, ignoring calling context causes a
                 50\% increase in slice size, and while (coarse-grained)
                 function-level slices are 33\% larger than
                 corresponding statement-level slices, they may be
                 useful predictors of the (finer-grained)
                 statement-level slice size. Finally, upstream analyses
                 have an order of magnitude less influence on slice
                 size.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Program slicing; slice size",
}

@Article{Gamatie:2007:PDE,
  author =       "Abdoulaye Gamati{\'e} and Thierry Gautier and Paul {Le
                 Guernic} and Jean-Pierre Talpin",
  title =        "Polychronous design of embedded real-time
                 applications",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "2",
  pages =        "9:1--9:??",
  month =        apr,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1217295.1217298",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Embedded real-time systems consist of hardware and
                 software that controls the behavior of a device or
                 plant. They are ubiquitous in today's technological
                 landscape and found in domains such as
                 telecommunications, nuclear power, avionics, and
                 medical technology. These systems are difficult to
                 design and build because they must satisfy both
                 functional and timing requirements to work correctly in
                 their intended environment. Furthermore, embedded
                 systems are often critical systems, where failure can
                 lead to loss of life, loss of mission, or serious
                 financial consequences. Because of the difficulty in
                 creating these systems and the consequences of failure,
                 they require rigorous and reliable design approaches.
                 The synchronous approach is one possible answer to this
                 demand. Its mathematical basis provides formal concepts
                 that favor the trusted design of embedded real-time
                 systems. The multiclock or polychronous model stands
                 out from other synchronous specification models by its
                 capability to enable the design of systems where each
                 component holds its own activation clock as well as
                 single-clocked systems in a uniform way. A great
                 advantage is its convenience for component-based design
                 approaches that enable modular development of
                 increasingly complex modern systems. The expressiveness
                 of its underlying semantics allows dealing with several
                 issues of real-time design. This article exposes
                 insights gained during recent years from the design of
                 real-time applications within the polychronous
                 framework. In particular, it shows promising results
                 about the design of applications from the avionics
                 domain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Avionics; IMA; Signal; Synchronous approach",
}

@Article{Kapoor:2007:TCF,
  author =       "Kalpesh Kapoor and Jonathan P. Bowen",
  title =        "Test conditions for fault classes in {Boolean}
                 specifications",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "3",
  pages =        "10:1--10:??",
  month =        jul,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1243987.1243988",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:41 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Fault-based testing of software checks the software
                 implementation for a set of faults. Two previous papers
                 on fault-based testing [Kuhn 1999; Tsuchiya and Kikuno
                 2002] represent the required behavior of the software
                 as a Boolean specification represented in Disjunctive
                 Normal Form (DNF) and then show that faults may be
                 organized in a hierarchy. This article extends these
                 results by identifying necessary and sufficient
                 conditions for fault-based testing. Unlike previous
                 solutions, the formal analysis used to derive these
                 conditions imposes no restrictions (such as DNF) on the
                 form of the Boolean specification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Boolean specification; fault classes; Fault-based
                 testing",
}

@Article{Paige:2007:MBM,
  author =       "Richard F. Paige and Phillip J. Brooke and Jonathan S.
                 Ostroff",
  title =        "Metamodel-based model conformance and multiview
                 consistency checking",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "3",
  pages =        "11:1--11:??",
  month =        jul,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1243987.1243989",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:41 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model-driven development, using languages such as UML
                 and BON, often makes use of multiple diagrams (e.g.,
                 class and sequence diagrams) when modeling systems.
                 These diagrams, presenting different views of a system
                 of interest, may be inconsistent. A metamodel provides
                 a unifying framework in which to ensure and check
                 consistency, while at the same time providing the means
                 to distinguish between valid and invalid models, that
                 is, conformance. Two formal specifications of the
                 metamodel for an object-oriented modeling language are
                 presented, and it is shown how to use these
                 specifications for model conformance and multiview
                 consistency checking. Comparisons are made in terms of
                 completeness and the level of automation each provide
                 for checking multiview consistency and model
                 conformance. The lessons learned from applying formal
                 techniques to the problems of metamodeling, model
                 conformance, and multiview consistency checking are
                 summarized.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "automated verification; formal methods; Metamodeling;
                 multiview consistency",
}

@Article{Basu:2007:MCJ,
  author =       "Samik Basu and Scott A. Smolka",
  title =        "Model checking the {Java} metalocking algorithm",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "3",
  pages =        "12:1--12:??",
  month =        jul,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1243987.1243990",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:41 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We report on our efforts to use the XMC model checker
                 to model and verify the Java metalocking algorithm. XMC
                 [Ramakrishna et al. 1997] is a versatile and efficient
                 model checker for systems specified in XL, a highly
                 expressive value-passing language. Metalocking [Agesen
                 et al. 1999] is a highly-optimized technique for
                 ensuring mutually exclusive access by threads to object
                 monitor queues and, therefore; plays an essential role
                 in allowing Java to offer concurrent access to objects.
                 Metalocking can be viewed as a two-tiered scheme. At
                 the upper level, the metalock level, a thread waits
                 until it can enqueue itself on an object's monitor
                 queue in a mutually exclusive manner. At the lower
                 level, the monitor-lock level, enqueued threads race to
                 obtain exclusive access to the object. Our abstract XL
                 specification of the metalocking algorithm is fully
                 parameterized, both on the number of threads M, and the
                 number of objects N. It also captures a sophisticated
                 optimization of the basic metalocking algorithm known
                 as extra-fast locking and unlocking of uncontended
                 objects. Using XMC, we show that for a variety of
                 values of M and N, the algorithm indeed provides mutual
                 exclusion and freedom from deadlock and lockout at the
                 metalock level. We also show that, while the
                 monitor-lock level of the protocol preserves mutual
                 exclusion and deadlock-freedom, it is not lockout-free
                 because the protocol's designers chose to give equal
                 preference to awaiting threads and newly arrived
                 threads.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Java; metalocking; monitor queues; mutual exclusion;
                 synchronized methods; XMC",
}

@Article{DeLucia:2007:RTL,
  author =       "Andrea {De Lucia} and Fausto Fasano and Rocco Oliveto
                 and Genoveffa Tortora",
  title =        "Recovering traceability links in software artifact
                 management systems using information retrieval
                 methods",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "4",
  pages =        "13:1--13:??",
  month =        sep,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1276933.1276934",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The main drawback of existing software artifact
                 management systems is the lack of automatic or
                 semi-automatic traceability link generation and
                 maintenance. We have improved an artifact management
                 system with a traceability recovery tool based on
                 Latent Semantic Indexing (LSI), an information
                 retrieval technique. We have assessed LSI to identify
                 strengths and limitations of using information
                 retrieval techniques for traceability recovery and
                 devised the need for an incremental approach. The
                 method and the tool have been evaluated during the
                 development of seventeen software projects involving
                 about 150 students. We observed that although tools
                 based on information retrieval provide a useful support
                 for the identification of traceability links during
                 software development, they are still far to support a
                 complete semi-automatic recovery of all links. The
                 results of our experience have also shown that such
                 tools can help to identify quality problems in the
                 textual description of traced artifacts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "impact analysis; latent semantic indexing; Software
                 artifact management; traceability management",
}

@Article{Wassermann:2007:SCD,
  author =       "Gary Wassermann and Carl Gould and Zhendong Su and
                 Premkumar Devanbu",
  title =        "Static checking of dynamically generated queries in
                 database applications",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "4",
  pages =        "14:1--14:??",
  month =        sep,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1276933.1276935",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many data-intensive applications dynamically construct
                 queries in response to client requests and execute
                 them. Java servlets, for example, can create strings
                 that represent SQL queries and then send the queries,
                 using JDBC, to a database server for execution. The
                 servlet programmer enjoys static checking via Java's
                 strong type system. However, the Java type system does
                 little to check for possible errors in the dynamically
                 generated SQL query strings. Thus, a type error in a
                 generated selection query (e.g., comparing a string
                 attribute with an integer) can result in an SQL runtime
                 exception. Currently, such defects must be rooted out
                 through careful testing, or (worse) might be found by
                 customers at runtime. In this article, we present a
                 sound, static program analysis technique to verify that
                 dynamically generated query strings do not contain type
                 errors. We describe our analysis technique and provide
                 soundness results for our static analysis algorithm. We
                 also describe the details of a prototype tool based on
                 the algorithm and present several illustrative defects
                 found in senior software-engineering student-team
                 projects, online tutorial examples, and a real-world
                 purchase order system written by one of the authors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "context-free language reachability; database queries;
                 JDBC; Static checking",
}

@Article{Baresi:2007:TES,
  author =       "Luciano Baresi and Sandro Morasca",
  title =        "Three empirical studies on estimating the design
                 effort of {Web} applications",
  journal =      j-TOSEM,
  volume =       "16",
  number =       "4",
  pages =        "15:1--15:??",
  month =        sep,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1276933.1276936",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:12:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Our research focuses on the effort needed for
                 designing modern Web applications. The design effort is
                 an important part of the total development effort,
                 since the implementation can be partially automated by
                 tools.\par

                 We carried out three empirical studies with students of
                 advanced university classes enrolled in engineering and
                 communication sciences curricula. The empirical studies
                 are based on the use of W2000, a special-purpose design
                 notation for the design of Web applications, but the
                 hypotheses and results may apply to a wider class of
                 modeling notations (e.g., OOHDM, WebML, or UWE). We
                 started by investigating the relative importance of
                 each design activity. We then assessed the accuracy of
                 a priori design effort predictions and the influence of
                 a few process-related factors on the effort needed for
                 each design activity. We also analyzed the impact of
                 attributes like the size and complexity of W2000 design
                 artifacts on the total effort needed to design the user
                 experience of web applications. In addition, we carried
                 out a finer-grain analysis, by studying which of these
                 attributes impact the effort devoted to the steps of
                 the design phase that are followed when using W2000.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "effort estimation; empirical study; W2000; Web
                 application design",
}

@Article{Notkin:2007:Ec,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "1",
  pages =        "1:1--1:2",
  month =        dec,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1314493.1314494",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:04 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Meyers:2007:ESS,
  author =       "Timothy M. Meyers and David Binkley",
  title =        "An empirical study of slice-based cohesion and
                 coupling metrics",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "1",
  pages =        "2:1--2:27",
  month =        dec,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1314493.1314495",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:04 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software reengineering is a costly endeavor, due in
                 part to the ambiguity of where to focus reengineering
                 effort. Coupling and Cohesion metrics, particularly
                 quantitative cohesion metrics, have the potential to
                 aid in this identification and to measure progress. The
                 most extensive work on such metrics is with slice-based
                 cohesion metrics. While their use of semantic
                 dependence information should make them an excellent
                 choice for cohesion measurement, their wide spread use
                 has been impeded in part by a lack of empirical
                 study.\par

                 Recent advances in software tools make, for the first
                 time, a large-scale empirical study of slice-based
                 cohesion and coupling metrics possible. Four results
                 from such a study are presented. First,
                 ``head-to-head'' qualitative and quantitative
                 comparisons of the metrics identify which metrics
                 provide similar views of a program and which provide
                 unique views of a program. This study includes
                 statistical analysis showing that slice-based metrics
                 are not proxies for simple size-based metrics such as
                 lines of code. Second, two longitudinal studies show
                 that slice-based metrics quantify the deterioration of
                 a program as it ages. This serves to validate the
                 metrics: the metrics quantify the degradation that
                 exists during development; turning this around, the
                 metrics can be used to measure the progress of a
                 reengineering effort. Third, baseline values for
                 slice-based metrics are provided. These values act as
                 targets for reengineering efforts with modules having
                 values outside the expected range being the most in
                 need of attention. Finally, slice-based coupling is
                 correlated and compared with slice-based cohesion.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "cohesion; coupling; reengineering; Slicing; software
                 intervention",
}

@Article{Marin:2007:ICC,
  author =       "Marius Marin and Arie {Van Deursen} and Leon Moonen",
  title =        "Identifying {Crosscutting Concerns Using Fan-In
                 Analysis}",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "1",
  pages =        "3:1--3:37",
  month =        dec,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1314493.1314496",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:04 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Aspect mining is a reverse engineering process that
                 aims at finding crosscutting concerns in existing
                 systems. This article proposes an aspect mining
                 approach based on determining methods that are called
                 from many different places, and hence have a high
                 fan-in, which can be seen as a symptom of crosscutting
                 functionality. The approach is semiautomatic, and
                 consists of three steps: metric calculation, method
                 filtering, and call site analysis. Carrying out these
                 steps is an interactive process supported by an Eclipse
                 plug-in called FINT. Fan-in analysis has been applied
                 to three open source Java systems, totaling around
                 200,000 lines of code. The most interesting concerns
                 identified are discussed in detail, which includes
                 several concerns not previously discussed in the
                 aspect-oriented literature. The results show that a
                 significant number of crosscutting concerns can be
                 recognized using fan-in analysis, and each of the three
                 steps can be supported by tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Aspect-oriented programming; crosscutting concerns;
                 fan-in metric; reverse engineering",
}

@Article{Frias:2007:EAD,
  author =       "Marcelo F. Frias and Carlos G. Lopez Pombo and Juan P.
                 Galeotti and Nazareno M. Aguirre",
  title =        "Efficient {Analysis} of {DynAlloy Specifications}",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "1",
  pages =        "4:1--4:34",
  month =        dec,
  year =         "2007",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1314493.1314497",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:04 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "DynAlloy is an extension of Alloy to support the
                 definition of actions and the specification of
                 assertions regarding execution traces. In this article
                 we show how we can extend the Alloy tool so that
                 DynAlloy specifications can be automatically analyzed
                 in an efficient way. We also demonstrate that
                 DynAlloy's semantics allows for a sound technique that
                 we call program atomization, which improves the
                 analyzability of properties regarding execution traces
                 by considering certain programs as atomic steps in a
                 trace.\par

                 We present the foundations, case studies, and empirical
                 results indicating that the analysis of DynAlloy
                 specifications can be performed efficiently.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Alloy; dynamic logic; software specification; software
                 validation",
}

@Article{Notkin:2008:Ea,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "5:1--5:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348251",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Notkin:2008:ISS,
  author =       "David Notkin and Mauro Pezz{\`e}",
  title =        "Introduction to the special section from the {ACM}
                 international symposium on software testing and
                 analysis {(ISSTA 2006)}",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "6:1--6:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348252",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cobleigh:2008:BHD,
  author =       "Jamieson M. Cobleigh and George S. Avrunin and Lori A.
                 Clarke",
  title =        "Breaking up is hard to do: an evaluation of automated
                 assume-guarantee reasoning",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "7:1--7:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348253",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Finite-state verification techniques are often
                 hampered by the state-explosion problem. One proposed
                 approach for addressing this problem is
                 assume-guarantee reasoning, where a system under
                 analysis is partitioned into subsystems and these
                 subsystems are analyzed individually. By composing the
                 results of these analyses, it can be determined whether
                 or not the system satisfies a property. Because each
                 subsystem is smaller than the whole system, analyzing
                 each subsystem individually may reduce the overall cost
                 of verification. Often the behavior of a subsystem is
                 dependent on the subsystems with which it interacts,
                 and thus it is usually necessary to provide assumptions
                 about the environment in which a subsystem executes.
                 Because developing assumptions has been a difficult
                 manual task, the evaluation of assume-guarantee
                 reasoning has been limited. Using recent advances for
                 automatically generating assumptions, we undertook a
                 study to determine if assume-guarantee reasoning
                 provides an advantage over monolithic verification. In
                 this study, we considered all two-way decompositions
                 for a set of systems and properties, using two
                 different verifiers, FLAVERS and LTSA. By increasing
                 the number of repeated tasks in these systems, we
                 evaluated the decompositions as they were scaled. We
                 found that in only a few cases can assume-guarantee
                 reasoning verify properties on larger systems than
                 monolithic verification can, and in these cases the
                 systems that can be analyzed are only a few sizes
                 larger. Although these results are discouraging, they
                 provide insight about research directions that should
                 be pursued and highlight the importance of experimental
                 evaluation in this area.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Assume-guarantee reasoning",
}

@Article{Csallner:2008:DCH,
  author =       "Christoph Csallner and Yannis Smaragdakis and Tao
                 Xie",
  title =        "{DSD-Crasher}: a hybrid analysis tool for bug
                 finding",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "8:1--8:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348254",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "DSD-Crasher is a bug finding tool that follows a
                 three-step approach to program analysis:\par

                 D. Capture the program's intended execution behavior
                 with dynamic invariant detection. The derived
                 invariants exclude many unwanted values from the
                 program's input domain.\par

                 S. Statically analyze the program within the restricted
                 input domain to explore many paths.\par

                 D. Automatically generate test cases that focus on
                 reproducing the predictions of the static analysis.
                 Thereby confirmed results are feasible.\par

                 This three-step approach yields benefits compared to
                 past two-step combinations in the literature. In our
                 evaluation with third-party applications, we
                 demonstrate higher precision over tools that lack a
                 dynamic step and higher efficiency over tools that lack
                 a static step.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Automatic testing; bug finding; dynamic analysis;
                 dynamic invariant detection; extended static checking;
                 false positives; static analysis; test case generation;
                 usability",
}

@Article{Fink:2008:ETV,
  author =       "Stephen J. Fink and Eran Yahav and Nurit Dor and G.
                 Ramalingam and Emmanuel Geay",
  title =        "Effective typestate verification in the presence of
                 aliasing",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "9:1--9:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348255",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article addresses the challenge of sound
                 typestate verification, with acceptable precision, for
                 real-world Java programs. We present a novel framework
                 for verification of typestate properties, including
                 several new techniques to precisely treat aliases
                 without undue performance costs. In particular, we
                 present a flow-sensitive, context-sensitive, integrated
                 verifier that utilizes a parametric abstract domain
                 combining typestate and aliasing information. To scale
                 to real programs without compromising precision, we
                 present a staged verification system in which faster
                 verifiers run as early stages which reduce the workload
                 for later, more precise, stages.\par

                 We have evaluated our framework on a number of real
                 Java programs, checking correct API usage for various
                 Java standard libraries. The results show that our
                 approach scales to hundreds of thousands of lines of
                 code, and verifies correctness for 93\% of the
                 potential points of failure.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Alias analysis; program verification; typestate",
}

@Article{Siegel:2008:CSE,
  author =       "Stephen F. Siegel and Anastasia Mironova and George S.
                 Avrunin and Lori A. Clarke",
  title =        "Combining symbolic execution with model checking to
                 verify parallel numerical programs",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "10:1--10:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348256",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present a method to verify the correctness of
                 parallel programs that perform complex numerical
                 computations, including computations involving
                 floating-point arithmetic. This method requires that a
                 sequential version of the program be provided, to serve
                 as the specification for the parallel one. The key idea
                 is to use model checking, together with symbolic
                 execution, to establish the equivalence of the two
                 programs. In this approach the path condition from
                 symbolic execution of the sequential program is used to
                 constrain the search through the parallel program. To
                 handle floating-point operations, three different types
                 of equivalence are supported. Several examples are
                 presented, demonstrating the approach and actual errors
                 that were found. Limitations and directions for future
                 research are also described.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "concurrency; Finite-state verification;
                 floating-point; high performance computing; Message
                 Passing Interface; model checking; MPI; numerical
                 program; parallel programming; Spin; symbolic
                 execution",
}

@Article{Tiwana:2008:ICD,
  author =       "Amrit Tiwana",
  title =        "Impact of classes of development coordination tools on
                 software development performance: a multinational
                 empirical study",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "2",
  pages =        "11:1--11:??",
  month =        apr,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1348250.1348257",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jun 16 11:13:13 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Although a diverse variety of software development
                 coordination tools are widely used in practice,
                 considerable debate surrounds their impact on software
                 development performance. No large-scale field research
                 has systematically examined their impact on software
                 development performance. This paper reports the results
                 of a multinational field study of software projects in
                 209 software development organizations to empirically
                 examine the influence of six key classes of development
                 coordination tools on the efficiency (reduction of
                 development rework, budget compliance) and
                 effectiveness (defect reduction) of software
                 development performance.\par

                 Based on an in-depth field study, the article
                 conceptualizes six holistic classes of development
                 coordination tools. The results provide nuanced
                 insights---some counter to prevailing beliefs---into
                 the relationships between the use of various classes of
                 development coordination tools and software development
                 performance. The overarching finding is that the
                 performance benefits of development coordination tools
                 are contingent on the salient types of novelty in a
                 project. The dimension of development
                 performance---efficiency or effectiveness---that each
                 class of tools is associated with varies systematically
                 with whether a project involves conceptual novelty,
                 process novelty, multidimensional novelty (both process
                 and conceptual novelty), or neither. Another noteworthy
                 insight is that the use of some classes of tools
                 introduces an efficiency-effectiveness tradeoff.
                 Collectively, the findings are among the first to offer
                 empirical support for the varied performance impacts of
                 various classes of development coordination tools and
                 have important implications for software development
                 practice. The paper also identifies several promising
                 areas for future research.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "collaborative software engineering. Software
                 outsourcing; coordination; development coordination
                 tools; development tools; efficiency effectiveness
                 tradeoff; empirical study; field study; knowledge
                 integration; knowledge management; outsourcing; project
                 management; regression analysis; Software development",
}

@Article{Notkin:2008:Eb,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "3",
  pages =        "12:1--12:??",
  month =        jun,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1363102.1363103",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 25 08:43:45 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mohagheghi:2008:EIS,
  author =       "Parastoo Mohagheghi and Reidar Conradi",
  title =        "An empirical investigation of software reuse benefits
                 in a large telecom product",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "3",
  pages =        "13:1--13:??",
  month =        jun,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1363102.1363104",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 25 08:43:45 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "{\em Background}. This article describes a case study
                 on the benefits of software reuse in a large telecom
                 product. The reused components were developed in-house
                 and shared in a product-family approach. {\em Methods}.
                 Quantitative data mined from company repositories are
                 combined with other quantitative data and qualitative
                 observations. {\em Results}. We observed significantly
                 lower fault density and less modified code between
                 successive releases of the reused components. Reuse and
                 standardization of software architecture and processes
                 allowed easier transfer of development when
                 organizational changes happened. {\em Conclusions}. The
                 study adds to the evidence of quality benefits of
                 large-scale reuse programs and explores organizational
                 motivations and outcomes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "fault density; product family; risks; software reuse;
                 standardization",
}

@Article{Henkel:2008:DDA,
  author =       "Johannes Henkel and Christoph Reichenbach and Amer
                 Diwan",
  title =        "Developing and debugging algebraic specifications for
                 {Java} classes",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "3",
  pages =        "14:1--14:??",
  month =        jun,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1363102.1363105",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 25 08:43:45 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Modern programs make extensive use of reusable
                 software libraries. For example, a study of a number of
                 large Java applications shows that between 17\% and
                 30\% of the classes in those applications use container
                 classes defined in the {\tt java.util} package. Given
                 this extensive code reuse in Java programs, it is
                 important for the interfaces of reusable classes to be
                 well documented. An interface is well documented if it
                 satisfies the following requirements: (1) the
                 documentation completely describes how to use the
                 interface; (2) the documentation is clear; (3) the
                 documentation is unambiguous; and (4) any deviation
                 between the documentation and the code is machine
                 detectable. Unfortunately, documentation in natural
                 language, which is the norm, does not satisfy the above
                 requirements. Formal specifications can satisfy them
                 but they are difficult to develop, requiring
                 significant effort on the part of programmers.\par

                 To address the practical difficulties with formal
                 specifications, we describe and evaluate a tool to help
                 programmers write and debug algebraic specifications.
                 Given an algebraic specification of a class, our
                 interpreter generates a prototype that can be used
                 within an application like a regular Java class. When
                 running an application that uses the prototype, the
                 interpreter prints error messages that tell the
                 developer in which way the specification is incomplete
                 or inconsistent with a hand-coded implementation of the
                 class. We use case studies to demonstrate the
                 usefulness of our system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "algebraic interpretation; algebraic specifications;
                 specification discovery",
}

@Article{Gencel:2008:FSM,
  author =       "Cigdem Gencel and Onur Demirors",
  title =        "Functional size measurement revisited",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "3",
  pages =        "15:1--15:??",
  month =        jun,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1363102.1363106",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 25 08:43:45 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "There are various approaches to software size
                 measurement. Among these, the metrics and methods based
                 on measuring the functionality attribute have become
                 widely used since the original method was introduced in
                 1979. Although functional size measurement methods have
                 gone a long way, they still provide challenges for
                 software managers. This article identifies improvement
                 opportunities based on empirical studies we performed
                 on ongoing projects. We also compare our findings with
                 the extended dataset provided by the International
                 Software Benchmarking Standards Group (ISBSG).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "COSMIC FFP; functional size measurement; MkII FPA;
                 software benchmarking; software estimation",
}

@Article{Chen:2008:UBS,
  author =       "Tsong Yueh Chen and Robert Merkel",
  title =        "An upper bound on software testing effectiveness",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "3",
  pages =        "16:1--16:??",
  month =        jun,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1363102.1363107",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 25 08:43:45 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Failure patterns describe typical ways in which inputs
                 revealing program failure are distributed across the
                 input domain --- in many cases, clustered together in
                 contiguous regions. Based on these observations several
                 debug testing methods have been developed. We examine
                 the upper bound of debug testing effectiveness
                 improvements possible through making assumptions about
                 the shape, size and orientation of failure patterns. We
                 consider the bounds for testing strategies with respect
                 to minimizing the F-measure, maximizing the P-measure,
                 and maximizing the E-measure. Surprisingly, we find
                 that the empirically measured effectiveness of some
                 existing methods that are not based on these
                 assumptions is close to the theoretical upper bound of
                 these strategies. The assumptions made to obtain the
                 upper bound, and its further implications, are also
                 examined.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "adaptive random testing; failure patterns;
                 failure-causing inputs; random testing; software
                 testing; testing effectiveness metrics",
}

@Article{Jalote:2008:PRR,
  author =       "Pankaj Jalote and Brendan Murphy and Vibhu Saujanya
                 Sharma",
  title =        "Post-release reliability growth in software products",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "4",
  pages =        "17:1--17:??",
  month =        aug,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/13487689.13487690",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 20 14:07:07 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Most software reliability growth models work under the
                 assumption that reliability of software grows due to
                 the removal of bugs that cause failures. However,
                 another phenomenon has often been observed --- the
                 failure rate of a software product following its
                 release decreases with time even if no bugs are
                 corrected. In this article we present a simple model to
                 represent this phenomenon. We introduce the concept of
                 initial transient failure rate of the product and
                 assume that it decays with a factor $ \alpha $ per unit
                 time thereby increasing the product reliability with
                 time. When the transient failure rate decays away, the
                 product displays a steady state failure rate. We
                 discuss how the parameters in this model --- initial
                 transient failure rate, decay factor, and steady state
                 failure rate --- can be determined from the failure and
                 sales data of a product. We also describe how, using
                 the model, we can determine the product stabilization
                 time --- a product quality metric that describes how
                 long it takes a product to reach close to its stable
                 failure rate. We provide many examples where this model
                 has been applied to data from released products.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "post-release reliability growth; product stabilization
                 time",
}

@Article{Robillard:2008:TAS,
  author =       "Martin P. Robillard",
  title =        "Topology analysis of software dependencies",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "4",
  pages =        "18:1--18:??",
  month =        aug,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/13487689.13487691",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 20 14:07:07 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Before performing a modification task, a developer
                 usually has to investigate the source code of a system
                 to understand how to carry out the task. Discovering
                 the code relevant to a change task is costly because it
                 is a human activity whose success depends on a large
                 number of unpredictable factors, such as intuition and
                 luck. Although studies have shown that effective
                 developers tend to explore a program by following
                 structural dependencies, no methodology is available to
                 guide their navigation through the thousands of
                 dependency paths found in a nontrivial program. We
                 describe a technique to automatically propose and rank
                 program elements that are potentially interesting to a
                 developer investigating source code. Our technique is
                 based on an analysis of the topology of structural
                 dependencies in a program. It takes as input a set of
                 program elements of interest to a developer and
                 produces a fuzzy set describing other elements of
                 potential interest. Empirical evaluation of our
                 technique indicates that it can help developers quickly
                 select program elements worthy of investigation while
                 avoiding less interesting ones.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "feature location; program understanding; separation of
                 concerns; software change; software evolution; software
                 navigation; static analysis",
}

@Article{Emmerich:2008:IRD,
  author =       "Wolfgang Emmerich and Mikio Aoyama and Joe Sventek",
  title =        "The impact of research on the development of
                 middleware technology",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "4",
  pages =        "19:1--19:??",
  month =        aug,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/13487689.13487692",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 20 14:07:07 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The middleware market represents a sizable segment of
                 the overall Information and Communication Technology
                 market. In 2005, the annual middleware license revenue
                 was reported by Gartner to be in the region of \$8.5
                 billion. In this article we address the question
                 whether research had any involvement in the creation of
                 the technology that is being sold in this market? We
                 attempt a scholarly discourse. We present the research
                 method that we have applied to answer this question. We
                 then present a brief introduction into the key
                 middleware concepts that provide the foundation for
                 this market. It would not be feasible to investigate
                 any possible impact that research might have had.
                 Instead we select a few very successful technologies
                 that are representative for the middleware market as a
                 whole and show the existence of impact of research
                 results in the creation of these technologies. We
                 investigate the origins of Web services middleware,
                 distributed transaction processing middleware,
                 message-oriented middleware, distributed object
                 middleware and remote procedure call systems. For each
                 of these technologies we are able to show ample
                 influence of research and conclude that without the
                 research conducted by PhD students and researchers in
                 university computer science labs at Brown, CMU,
                 Cambridge, Newcastle, MIT, Vrije, and University of
                 Washington as well as research in industrial labs at
                 APM, AT\&T Bell Labs, DEC Systems Research, HP Labs,
                 IBM Research, and Xerox PARC we would not have
                 middleware technology in its current form. We summarise
                 the article by distilling lessons that can be learnt
                 from this evidenced impact for future technology
                 transfer undertakings.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gruschke:2008:ROF,
  author =       "Tanja M. Gruschke and Magne J{\o}rgensen",
  title =        "The role of outcome feedback in improving the
                 uncertainty assessment of software development effort
                 estimates",
  journal =      j-TOSEM,
  volume =       "17",
  number =       "4",
  pages =        "20:1--20:??",
  month =        aug,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/13487689.13487693",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 20 14:07:07 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Previous studies report that software developers are
                 over-confident in the accuracy of their effort
                 estimates. Aim: This study investigates the role of
                 outcome feedback, that is, feedback about the
                 discrepancy between the estimated and the actual
                 effort, in improving the uncertainty assessments.
                 Method: We conducted two in-depth empirical studies on
                 uncertainty assessment learning. Study 1 included five
                 student developers and Study 2, 10 software
                 professionals. In each study the developers repeatedly
                 assessed the uncertainty of their effort estimates of a
                 programming task, solved the task, and received
                 estimation accuracy outcome feedback. Results: We found
                 that most, but not all, developers were initially
                 over-confident in the accuracy of their effort
                 estimates and remained over-confident in spite of
                 repeated and timely outcome feedback. One important,
                 but not sufficient, condition for improvement based on
                 outcome feedback seems to be the use of explicitly
                 formulated, instead of purely intuition-based,
                 uncertainty assessment strategies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "cost estimation; effort prediction intervals;
                 judgment-based uncertainty assessment; overconfidence;
                 software cost estimation; software development
                 management",
}

@Article{Karam:2008:ULT,
  author =       "Marcel R. Karam and Trevor J. Smedley and Sergiu M.
                 Dascalu",
  title =        "Unit-level test adequacy criteria for visual dataflow
                 languages and a testing methodology",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "1",
  pages =        "1:1--1:??",
  month =        sep,
  year =         "2008",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Oct 6 15:14:19 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Visual dataflow languages (VDFLs), which include
                 commercial and research systems, have had a substantial
                 impact on end-user programming. Like any other
                 programming languages, whether visual or textual, VDFLs
                 often contain faults. A desire to provide programmers
                 of these languages with some of the benefits of
                 traditional testing methodologies has been the driving
                 force behind our effort in this work. In this article
                 we introduce, in the context of Prograph, a testing
                 methodology for VDFLs based on structural test adequacy
                 criteria and coverage. This article also reports on the
                 results of two empirical studies. The first study was
                 conducted to obtain meaningful information about, in
                 particular, the effectiveness of our all-Dus criteria
                 in detecting a reasonable percentage of faults in
                 VDFLs. The second study was conducted to evaluate,
                 under the same criterion, the effectiveness of our
                 methodology in assisting users to visually localize
                 faults by reducing their search space. Both studies
                 were conducted using a testing system that we have
                 implemented in Prograph's IDE.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Louridas:2008:PLS,
  author =       "Panagiotis Louridas and Diomidis Spinellis and
                 Vasileios Vlachos",
  title =        "Power laws in software",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "1",
  pages =        "2:1--2:??",
  month =        sep,
  year =         "2008",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Oct 6 15:14:19 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A single statistical framework, comprising power law
                 distributions and scale-free networks, seems to fit a
                 wide variety of phenomena. There is evidence that power
                 laws appear in software at the class and function
                 level. We show that distributions with long, fat tails
                 in software are much more pervasive than previously
                 established, appearing at various levels of
                 abstraction, in diverse systems and languages. The
                 implications of this phenomenon cover various aspects
                 of software engineering research and practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lhotak:2008:EBC,
  author =       "Ond{\v{r}}ej Lhot{\'a}k and Laurie Hendren",
  title =        "Evaluating the benefits of context-sensitive points-to
                 analysis using a {BDD}-based implementation",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "1",
  pages =        "3:1--3:??",
  month =        sep,
  year =         "2008",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Oct 6 15:14:19 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present Paddle, a framework of BDD-based
                 context-sensitive points-to and call graph analyses for
                 Java, as well as client analyses that use their
                 results. Paddle supports several variations of
                 context-sensitive analyses, including call site strings
                 and object sensitivity, and context-sensitively
                 specializes both pointer variables and the heap
                 abstraction. We empirically evaluate the precision of
                 these context-sensitive analyses on significant Java
                 programs. We find that object-sensitive analyses are
                 more precise than comparable variations of the other
                 approaches, and that specializing the heap abstraction
                 improves precision more than extending the length of
                 context strings.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Memon:2008:ARE,
  author =       "Atif M. Memon",
  title =        "Automatically repairing event sequence-based {GUI}
                 test suites for regression testing",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "2",
  pages =        "4:1--4:??",
  month =        nov,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1416563.1416564",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Nov 11 15:45:20 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Although graphical user interfaces (GUIs) constitute a
                 large part of the software being developed today and
                 are typically created using rapid prototyping, there
                 are no effective regression testing techniques for
                 GUIs. The needs of GUI regression testing differ from
                 those of traditional software. When the structure of a
                 GUI is modified, test cases from the original GUI's
                 suite are either reusable or unusable on the modified
                 GUI. Because GUI test case generation is expensive, our
                 goal is to make the unusable test cases usable, thereby
                 helping to retain the suite's event coverage. The idea
                 of reusing these unusable ({\em obsolete\/}) test cases
                 has not been explored before. This article shows that a
                 large number of test cases become unusable for GUIs. It
                 presents a new GUI regression testing technique that
                 first automatically determines the usable and unusable
                 test cases from a test suite after a GUI modification,
                 then determines the unusable test cases that can be
                 repaired so that they can execute on the modified GUI,
                 and finally uses {\em repairing transformations\/} to
                 repair the test cases. This regression testing
                 technique along with four repairing transformations has
                 been implemented. An empirical study for four
                 open-source applications demonstrates that (1) this
                 approach is effective in that many of the test cases
                 can be repaired, and is practical in terms of its time
                 performance, (2) certain types of test cases are more
                 prone to becoming unusable, and (3) certain types of
                 ``dominator'' events, when modified, make a large
                 number of test cases unusable.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Graphical user interfaces; regression testing;
                 repairing test cases; test case management; test
                 maintenance",
}

@Article{Breaux:2008:SPP,
  author =       "Travis D. Breaux and Annie I. Ant{\'o}n and Jon
                 Doyle",
  title =        "Semantic parameterization: a process for modeling
                 domain descriptions",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "2",
  pages =        "5:1--5:??",
  month =        nov,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1416563.1416565",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Nov 11 15:45:20 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software engineers must systematically account for the
                 broad scope of environmental behavior, including
                 nonfunctional requirements, intended to coordinate the
                 actions of stakeholders and software systems. The
                 Inquiry Cycle Model (ICM) provides engineers with a
                 strategy to acquire and refine these requirements by
                 having domain experts answer six questions: who, what,
                 where, when, how, and why. Goal-based requirements
                 engineering has led to the formalization of
                 requirements to answer the ICM questions about {\em
                 when}, {\em how}, and {\em why\/} goals are achieved,
                 maintained, or avoided. In this article, we present a
                 systematic process called {\em Semantic
                 Parameterization\/} for expressing natural language
                 domain descriptions of goals as specifications in
                 description logic. The formalization of goals in
                 description logic allows engineers to automate
                 inquiries using {\em who}, {\em what}, and {\em
                 where\/} questions, completing the formalization of the
                 ICM questions. The contributions of this approach
                 include new theory to conceptually compare and
                 disambiguate goal specifications that enables querying
                 goals and organizing goals into specialization
                 hierarchies. The artifacts in the process include a
                 dictionary that aligns the domain lexicon with unique
                 concepts, distinguishing between synonyms and
                 polysemes, and several natural language patterns that
                 aid engineers in mapping common domain descriptions to
                 formal specifications. Semantic Parameterization has
                 been empirically validated in three case studies on
                 policy and regulatory descriptions that govern
                 information systems in the finance and health-care
                 domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "description logic; domain knowledge; formal
                 specification; Natural language",
}

@Article{Huang:2008:DSL,
  author =       "Shan Shan Huang and David Zook and Yannis
                 Smaragdakis",
  title =        "Domain-specific languages and program generation with
                 {meta-AspectJ}",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "2",
  pages =        "6:1--6:??",
  month =        nov,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1416563.1416566",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Nov 11 15:45:20 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Meta-AspectJ (MAJ) is a language for generating
                 AspectJ programs using code templates. MAJ itself is an
                 extension of Java, so users can interleave arbitrary
                 Java code with AspectJ code templates. MAJ is a
                 structured metaprogramming tool: a well-typed generator
                 implies a syntactically correct generated program. MAJ
                 promotes a methodology that combines aspect-oriented
                 and generative programming. A valuable application is
                 in implementing small domain-specific language
                 extensions as generators using unobtrusive annotations
                 for syntax extension and AspectJ as a back-end. The
                 advantages of this approach are twofold. First, the
                 generator integrates into an existing software
                 application much as a regular API or library, instead
                 of as a language extension. Second, a mature language
                 implementation is easy to achieve with little effort
                 since AspectJ takes care of the low-level issues of
                 interfacing with the base Java language.\par

                 In addition to its practical value, MAJ offers valuable
                 insights to metaprogramming tool designers. It is a
                 mature metaprogramming tool for AspectJ (and, by
                 extension, Java): a lot of emphasis has been placed on
                 context-sensitive parsing and error reporting. As a
                 result, MAJ minimizes the number of metaprogramming
                 (quote/unquote) operators and uses type inference to
                 reduce the need to remember type names for syntactic
                 entities.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "domain-specific languages; language extensions;
                 Metaprogramming; program synthesis; program
                 transformation; program verification",
}

@Article{Xie:2008:UPS,
  author =       "Qing Xie and Atif M. Memon",
  title =        "Using a pilot study to derive a {GUI} model for
                 automated testing",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "2",
  pages =        "7:1--7:??",
  month =        nov,
  year =         "2008",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1416563.1416567",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Nov 11 15:45:20 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Graphical user interfaces (GUIs) are one of the most
                 commonly used parts of today's software. Despite their
                 ubiquity, testing GUIs for functional correctness
                 remains an understudied area. A typical GUI gives many
                 degrees of freedom to an end-user, leading to an
                 enormous {\em input event interaction space\/} that
                 needs to be tested. GUI test designers generate and
                 execute test cases (modeled as sequences of user {\em
                 events\/}) to traverse its parts; targeting a subspace
                 in order to maximize fault detection is a nontrivial
                 task. In this vein, in previous work, we used informal
                 GUI code examination and personal intuition to develop
                 an {\em event-interaction graph\/} (EIG). In this
                 article we empirically derive the EIG model via a pilot
                 study, and the resulting EIG validates our intuition
                 used in previous work; the empirical derivation process
                 also allows for model evolution as our understanding of
                 GUI faults improves. Results of the pilot study show
                 that events interact in complex ways; a GUI's response
                 to an event may vary depending on the {\em context\/}
                 established by preceding events and their execution
                 order. The EIG model helps testers to understand the
                 nature of interactions between GUI events when executed
                 in test cases and why certain events detect faults, so
                 that they can better traverse the event space. New test
                 adequacy criteria are defined for the EIG; new
                 algorithms use these criteria and EIG to systematically
                 generate test cases that are shown to be effective on
                 four fielded open-source applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Graphical user interfaces; model-based testing; test
                 minimization; test suite management",
}

@Article{Notkin:2009:E,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "3",
  pages =        "8:1--8:??",
  month =        may,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1525880.1525881",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 3 16:34:58 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bauer:2009:CER,
  author =       "Lujo Bauer and Jay Ligatti and David Walker",
  title =        "Composing expressive runtime security policies",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "3",
  pages =        "9:1--9:??",
  month =        may,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1525880.1525882",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 3 16:34:58 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Program monitors enforce security policies by
                 interposing themselves into the control flow of
                 untrusted software whenever that software attempts to
                 execute security-relevant actions. At the point of
                 interposition, a monitor has authority to permit or
                 deny (perhaps conditionally) the untrusted software's
                 attempted action. Program monitors are common security
                 enforcement mechanisms and integral parts of operating
                 systems, virtual machines, firewalls, network auditors,
                 and antivirus and antispyware tools.\par

                 Unfortunately, the runtime policies we require program
                 monitors to enforce grow more complex, both as the
                 monitored software is given new capabilities and as
                 policies are refined in response to attacks and user
                 feedback. We propose dealing with policy complexity by
                 organizing policies in such a way as to make them
                 composable, so that complex policies can be specified
                 more simply as compositions of smaller subpolicy
                 modules. We present a fully implemented language and
                 system called Polymer that allows security engineers to
                 specify and enforce composable policies on Java
                 applications. We formalize the central workings of
                 Polymer by defining an unambiguous semantics for our
                 language. Using this formalization, we state and prove
                 an uncircumventability theorem which guarantees that
                 monitors will intercept all security-relevant actions
                 of untrusted software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Policy composition; policy enforcement;
                 policy-specification language",
}

@Article{Hall:2009:SRT,
  author =       "Tracy Hall and Nathan Baddoo and Sarah Beecham and
                 Hugh Robinson and Helen Sharp",
  title =        "A systematic review of theory use in studies
                 investigating the motivations of software engineers",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "3",
  pages =        "10:1--10:??",
  month =        may,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1525880.1525883",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 3 16:34:58 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Motivated software engineers make a critical
                 contribution to delivering successful software systems.
                 Understanding the motivations of software engineers and
                 the impact of motivation on software engineering
                 outcomes could significantly affect the industry's
                 ability to deliver good quality software systems.
                 Understanding the motivations of people generally in
                 relation to their work is underpinned by eight classic
                 motivation theories from the social sciences. We would
                 expect these classic motivation theories to play an
                 important role in developing a rigorous understanding
                 of the specific motivations of software engineers. In
                 this article we investigate how this theoretical basis
                 has been exploited in previous studies of software
                 engineering. We analyzed 92 studies of motivation in
                 software engineering that were published in the
                 literature between 1980 and 2006. Our main findings are
                 that many studies of software engineers' motivations
                 are not explicitly underpinned by reference to the
                 classic motivation theories. Furthermore, the findings
                 presented in these studies are often not explicitly
                 interpreted in terms of those theories, despite the
                 fact that in many cases there is a relationship between
                 those findings and the theories. Our conclusion is that
                 although there has been a great deal of previous work
                 looking at motivation in software engineering, the lack
                 of reference to classic theories of motivation means
                 that the current body of work in the area is weakened
                 and our understanding of motivation in software
                 engineering is not as rigorous as it may at first
                 appear. This weakness in the current state of knowledge
                 highlights important areas for future researchers to
                 contribute towards developing a rigorous and usable
                 body of knowledge in motivating software engineers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Motivation; software engineering",
}

@Article{McMinn:2009:EEN,
  author =       "Phil McMinn and David Binkley and Mark Harman",
  title =        "Empirical evaluation of a nesting testability
                 transformation for evolutionary testing",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "3",
  pages =        "11:1--11:??",
  month =        may,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1525880.1525884",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 3 16:34:58 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Evolutionary testing is an approach to automating test
                 data generation that uses an evolutionary algorithm to
                 search a test object's input domain for test data.
                 Nested predicates can cause problems for evolutionary
                 testing, because information needed for guiding the
                 search only becomes available as each nested
                 conditional is satisfied. This means that the search
                 process can overfit to early information, making it
                 harder, and sometimes near impossible, to satisfy
                 constraints that only become apparent later in the
                 search. The article presents a testability
                 transformation that allows the evaluation of all nested
                 conditionals at once. Two empirical studies are
                 presented. The first study shows that the form of
                 nesting handled is prevalent in practice. The second
                 study shows how the approach improves evolutionary test
                 data generation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Evolutionary testing; search-based software
                 engineering; test data generation; testability
                 transformation",
}

@Article{Hamlet:2009:TES,
  author =       "Dick Hamlet",
  title =        "Tools and experiments supporting a testing-based
                 theory of component composition",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "3",
  pages =        "12:1--12:??",
  month =        may,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1525880.1525885",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jun 3 16:34:58 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Development of software using off-the-shelf components
                 seems to offer a chance for improving product quality
                 and developer productivity. This article reviews a
                 foundational testing-based theory of component
                 composition, describes tools that implement the theory,
                 and presents experiments with functional and
                 nonfunctional component/system properties that validate
                 the theory and illuminate issues in component
                 composition.\par

                 The context for this work is an ideal form of
                 Component-Based Software Development (CBSD) supported
                 by tools. Component developers describe their
                 components by measuring approximations to functional
                 and nonfunctional behavior on a finite collection of
                 subdomains. Systems designers describe an
                 application-system structure by the component
                 connections that form it. From measured component
                 descriptions and a system structure, a CAD tool
                 synthesizes the system properties, predicting how the
                 system will behave. The system is not built, nor are
                 any test executions performed. Neither the component
                 sources nor executables are needed by systems
                 designers. From CAD calculations a designer can learn
                 (approximately) anything that could be learned by
                 testing an actual system implementation. The CAD tool
                 is often more efficient than it would be to assemble
                 and execute an actual system.\par

                 Using tools that support an ideal separation between
                 component- and system development, experiments were
                 conducted to investigate two related questions: (1) To
                 what extent can unit (that is, component) testing
                 replace system testing? (2) What properties of software
                 and subdomains influence the quality of subdomain
                 testing?",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "CAD tool support for CBSD; component-based software
                 development (CBSD); Experiments with composition of
                 software components; synthesis of system properties",
}

@Article{Goel:2009:IPC,
  author =       "Ankit Goel and Abhik Roychoudhury and P. S.
                 Thiagarajan",
  title =        "Interacting process classes",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "4",
  pages =        "13:1--13:??",
  month =        jul,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1538942.1538943",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:32 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many reactive control systems consist of classes of
                 active objects involving both intraclass interactions
                 (i.e., objects belonging to the same class interacting
                 with each other) and interclass interactions. Such
                 reactive control systems appear in domains such as
                 telecommunication, transportation and avionics. In this
                 article, we propose a modeling and simulation technique
                 for interacting process classes. Our modeling style
                 uses standard notations to capture behavior. In
                 particular, the control flow of a process class is
                 captured by a labeled transition system, unit
                 interactions between process objects are described as
                 {\em transactions}, and the structural relations are
                 captured via class diagrams. The key feature of our
                 approach is that our execution semantics leads to an
                 {\em abstract\/} simulation technique which involves
                 (i) grouping together active objects into equivalence
                 classes according their potential futures, and (ii)
                 keeping track of the number of objects in an
                 equivalence class rather than their identities. Our
                 simulation strategy is both time and memory efficient
                 and we demonstrate this on well-studied nontrivial
                 examples of reactive systems. We also present a case
                 study involving a weather-update controller from NASA
                 to demonstrate the use of our simulator for debugging
                 realistic designs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Abstract execution; active objects; message sequence
                 charts; Unified Modeling Language (UML)",
}

@Article{Hierons:2009:VFT,
  author =       "Robert M. Hierons",
  title =        "Verdict functions in testing with a fault domain or
                 test hypotheses",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "4",
  pages =        "14:1--14:??",
  month =        jul,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1538942.1538944",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:32 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In state-based testing, it is common to include
                 verdicts within test cases, the result of the test case
                 being the verdict reached by the test run. In addition,
                 approaches that reason about test effectiveness or
                 produce tests that are guaranteed to find certain
                 classes of faults are often based on either a fault
                 domain or a set of test hypotheses. This article
                 considers how the presence of a fault domain or test
                 hypotheses affects our notion of a test verdict. The
                 analysis reveals the need for new verdicts that provide
                 more information than the current verdicts and for
                 verdict functions that return a verdict based on a set
                 of test runs rather than a single test run. The
                 concepts are illustrated in the contexts of testing
                 from a nondeterministic finite state machine and the
                 testing of a datatype specified using an algebraic
                 specification language but are potentially relevant
                 whenever fault domains or test hypotheses are used.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "fault domains; test hypotheses; Test verdicts",
}

@Article{Mamei:2009:PPM,
  author =       "Marco Mamei and Franco Zambonelli",
  title =        "Programming pervasive and mobile computing
                 applications: {The TOTA} approach",
  journal =      j-TOSEM,
  volume =       "18",
  number =       "4",
  pages =        "15:1--15:??",
  month =        jul,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1538942.1538945",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:32 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Pervasive and mobile computing call for suitable
                 middleware and programming models to support the
                 activities of complex software systems in dynamic
                 network environments. In this article we present TOTA
                 (``Tuples On The Air''), a novel middleware and
                 programming approach for supporting adaptive
                 context-aware activities in pervasive and mobile
                 computing scenarios. The key idea in TOTA is to rely on
                 spatially distributed tuples, adaptively propagated
                 across a network on the basis of application-specific
                 rules, for both representing contextual information and
                 supporting uncoupled interactions between application
                 components. TOTA promotes a simple way of programming
                 that facilitates access to distributed information,
                 navigation in complex environments, and the achievement
                 of complex coordination tasks in a fully distributed
                 and adaptive way, mostly freeing programmers and system
                 managers from the need to take care of low-level issues
                 related to network dynamics. This article includes both
                 application examples to clarify concepts and
                 performance figures to show the feasibility of the
                 approach",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "coordination; middleware; mobile computing; Pervasive
                 computing; self-adaptation; self-organization; tuple
                 spaces",
}

@Article{Tilevich:2009:JOE,
  author =       "Eli Tilevich and Yannis Smaragdakis",
  title =        "{J-Orchestra}: {Enhancing} {Java} programs with
                 distribution capabilities",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "1",
  pages =        "1:1--1:??",
  month =        aug,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1555392.1555394",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:39 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "J-Orchestra is a system that enhances centralized Java
                 programs with distribution capabilities. Operating at
                 the bytecode level, J-Orchestra transforms a
                 centralized Java program (i.e., running on a single
                 Java Virtual Machine (JVM)) into a distributed one
                 (i.e., running across multiple JVMs). This
                 transformation effectively separates distribution
                 concerns from the core functionality of a program.
                 J-Orchestra follows a semiautomatic transformation
                 process. Through a GUI, the user selects program
                 elements (at class granularity) and assigns them to
                 network locations. Based on the user's input, the
                 J-Orchestra backend {\em automatically partitions\/}
                 the program through compiler-level techniques, without
                 changes to the JVM or to the Java Runtime Environment
                 (JRE) classes. By means of bytecode engineering and
                 code generation, J-Orchestra substitutes method calls
                 with remote method calls, direct object references with
                 proxy references, etc. It also translates Java language
                 features (e.g., static methods and fields, inheritance,
                 inner classes, new object construction, etc.) for
                 efficient distributed execution.\par

                 We detail the main technical issues that J-Orchestra
                 addresses, including its mechanism for program
                 transformation in the presence of unmodifiable code
                 (e.g., in JRE classes) and the translation of
                 concurrency and synchronization constructs to work
                 correctly over the network. We further discuss a case
                 study of transforming a large, commercial, third-party
                 application for efficient execution in a client server
                 environment and outline the architectural
                 characteristics of centralized programs that are
                 amenable to automated distribution with J-Orchestra.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "bytecode engineering; distributed computing; Java;
                 middleware; RMI; Separation of concerns",
}

@Article{Ouyang:2009:BPM,
  author =       "Chun Ouyang and Marlon Dumas and Wil M. P. {Van Der
                 Aalst} and Arthur H. M. {Ter Hofstede} and Jan
                 Mendling",
  title =        "From business process models to process-oriented
                 software systems",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "1",
  pages =        "2:1--2:??",
  month =        aug,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1555392.1555395",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:39 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Several methods for enterprise systems analysis rely
                 on flow-oriented representations of business
                 operations, otherwise known as business process models.
                 The Business Process Modeling Notation (BPMN) is a
                 standard for capturing such models. BPMN models
                 facilitate communication between domain experts and
                 analysts and provide input to software development
                 projects. Meanwhile, there is an emergence of methods
                 for enterprise software development that rely on
                 detailed process definitions that are executed by
                 process engines. These process definitions refine their
                 counterpart BPMN models by introducing data
                 manipulation, application binding, and other
                 implementation details. The de facto standard for
                 defining executable processes is the Business Process
                 Execution Language (BPEL). Accordingly, a
                 standards-based method for developing process-oriented
                 systems is to start with BPMN models and to translate
                 these models into BPEL definitions for subsequent
                 refinement. However, instrumenting this method is
                 challenging because BPMN models and BPEL definitions
                 are structurally very different. Existing techniques
                 for translating BPMN to BPEL only work for limited
                 classes of BPMN models. This article proposes a
                 translation technique that does not impose structural
                 restrictions on the source BPMN model. At the same
                 time, the technique emphasizes the generation of
                 readable (block-structured) BPEL code. An empirical
                 evaluation conducted over a large collection of process
                 models shows that the resulting BPEL definitions are
                 largely block-structured. Beyond its direct relevance
                 in the context of BPMN and BPEL, the technique
                 presented in this article addresses issues that arise
                 when translating from graph-oriented to block-structure
                 flow definition languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "BPEL; BPMN; Business process modeling; Web services",
}

@Article{Rajan:2009:UAO,
  author =       "Hridesh Rajan and Kevin J. Sullivan",
  title =        "Unifying aspect- and object-oriented design",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "1",
  pages =        "3:1--3:??",
  month =        aug,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1555392.1555396",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 11 19:18:39 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The contribution of this work is the design and
                 evaluation of a programming language model that unifies
                 aspects and classes as they appear in AspectJ-like
                 languages. We show that our model preserves the
                 capabilities of AspectJ-like languages, while improving
                 the conceptual integrity of the language model and the
                 compositionality of modules. The improvement in
                 conceptual integrity is manifested by the reduction of
                 specialized constructs in favor of uniform orthogonal
                 constructs. The enhancement in compositionality is
                 demonstrated by better modularization of integration
                 and higher-order crosscutting concerns.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "aspect-oriented programming; binding; Classpect; Eos;
                 first class aspect instances; instance-level advising;
                 unified aspect language model",
}

@Article{Tan:2009:CDM,
  author =       "Hee Beng Kuan Tan and Yuan Zhao and Hongyu Zhang",
  title =        "Conceptual data model-based software size estimation
                 for information systems",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "2",
  pages =        "4:1--4:??",
  month =        oct,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1571629.1571630",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 9 20:39:35 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Size estimation plays a key role in effort estimation
                 that has a crucial impact on software projects in the
                 software industry. Some information required by
                 existing software sizing methods is difficult to
                 predict in the early stage of software development. A
                 conceptual data model is widely used in the early stage
                 of requirements analysis for information systems. Lines
                 of code (LOC) is a commonly used software size measure.
                 This article proposes a novel LOC estimation method for
                 information systems from their conceptual data models
                 through using a multiple linear regression model. We
                 have validated the proposed method using samples from
                 both the software industry and open-source systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "conceptual data model; line of code (LOC); multiple
                 linear regression model; Software sizing",
}

@Article{Masri:2009:MSI,
  author =       "Wes Masri and Andy Podgurski",
  title =        "Measuring the strength of information flows in
                 programs",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "2",
  pages =        "5:1--5:??",
  month =        oct,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1571629.1571631",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 9 20:39:35 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "{\em Dynamic information flow analysis\/} (DIFA) was
                 devised to enable the flow of information among
                 variables in an executing program to be monitored and
                 possibly regulated. It is related to techniques like
                 {\em dynamic slicing\/} and {\em dynamic impact
                 analysis}. To better understand the basis for DIFA, we
                 conducted an empirical study in which we measured the
                 {\em strength\/} of information flows identified by
                 DIFA, using information theoretic and correlation-based
                 methods. The results indicate that in most cases the
                 occurrence of a chain of dynamic program dependences
                 between two variables does {\em not\/} indicate a
                 measurable information flow between them. We also
                 explored the relationship between the strength of an
                 information flow and the {\em length\/} of the
                 corresponding dependence chain, and we obtained results
                 indicating that no consistent relationship exists
                 between the length of an information flow and its
                 strength. Finally, we investigated whether data
                 dependence and control dependence makes equal or
                 unequal contributions to flow strength. The results
                 indicate that flows due to data dependences alone are
                 stronger, on average, than flows due to control
                 dependences alone. We present the details of our study
                 and consider the implications of the results for
                 applications of DIFA and related techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "correlation; Dynamic information flow analysis;
                 dynamic slicing; entropy; information flow length;
                 information flow strength; information leakage; program
                 dependence",
}

@Article{Desai:2009:AMM,
  author =       "Nirmit Desai and Amit K. Chopra and Munindar P.
                 Singh",
  title =        "{Amoeba}: a methodology for modeling and evolving
                 cross-organizational business processes",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "2",
  pages =        "6:1--6:??",
  month =        oct,
  year =         "2009",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1571629.1571632",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Oct 9 20:39:35 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Business service engagements involve processes that
                 extend across two or more autonomous organizations.
                 Because of regulatory and competitive reasons,
                 requirements for cross-organizational business
                 processes often evolve in subtle ways. The changes may
                 concern the business transactions supported by a
                 process, the organizational structure of the parties
                 participating in the process, or the contextual
                 policies that apply to the process. Current business
                 process modeling approaches handle such changes in an
                 ad hoc manner, and lack a principled means for
                 determining what needs to be changed and where.
                 Cross-organizational settings exacerbate the
                 shortcomings of traditional approaches because changes
                 in one organization can potentially affect the workings
                 of another.\par

                 This article describes Amoeba, a methodology for
                 business processes that is based on {\em business
                 protocols}. Protocols capture the business meaning of
                 interactions among autonomous parties via commitments.
                 Amoeba includes guidelines for (1) specifying
                 cross-organizational processes using business
                 protocols, and (2) handling the evolution of
                 requirements via a novel application of protocol
                 composition. This article evaluates Amoeba using
                 enhancements of a real-life business scenario of
                 auto-insurance claim processing, and an aerospace case
                 study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Business process modeling; business protocols;
                 requirements evolution",
}

@Article{Notkin:2010:E,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "3",
  pages =        "7:1--7:??",
  month =        jan,
  year =         "2010",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 15 13:32:11 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Whittle:2010:SHS,
  author =       "Jon Whittle and Praveen K. Jayaraman",
  title =        "Synthesizing hierarchical state machines from
                 expressive scenario descriptions",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "3",
  pages =        "8:1--8:??",
  month =        jan,
  year =         "2010",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 15 13:32:11 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2010:PCC,
  author =       "Chang Xu and S. C. Cheung and W. K. Chan and Chunyang
                 Ye",
  title =        "Partial constraint checking for context consistency in
                 pervasive computing",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "3",
  pages =        "9:1--9:??",
  month =        jan,
  year =         "2010",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 15 13:32:11 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Brogi:2010:DIS,
  author =       "Antonio Brogi and Razvan Popescu and Matteo Tanca",
  title =        "Design and implementation of {Sator}: a {Web} service
                 aggregator",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "3",
  pages =        "10:1--10:??",
  month =        jan,
  year =         "2010",
  CODEN =        "ATSMER",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 15 13:32:11 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ponge:2010:AAT,
  author =       "Julien Ponge and Boualem Benatallah and Fabio Casati
                 and Farouk Toumani",
  title =        "Analysis and applications of timed service protocols",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "4",
  pages =        "11:1--11:??",
  month =        apr,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1734229.1734230",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 21 11:41:14 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Web services are increasingly gaining acceptance as a
                 framework for facilitating application-to-application
                 interactions within and across enterprises. It is
                 commonly accepted that a service description should
                 include not only the interface, but also the business
                 protocol supported by the service. The present work
                 focuses on the formalization of an important category
                 of protocols that includes time-related constraints
                 (called {\em timed protocols\/}), and the impact of
                 time on compatibility and replaceability analysis. We
                 formalized the following timing constraints: C-Invoke
                 constraints define time windows within which a service
                 operation can be invoked while M-Invoke constraints
                 define expiration deadlines. We extended techniques for
                 compatibility and replaceability analysis between timed
                 protocols by using a semantic-preserving mapping
                 between timed protocols and timed automata, leading to
                 the identification of a novel class of timed automata,
                 called {\em protocol timed automata\/} (PTA). PTA
                 exhibit a particular kind of silent transition that
                 strictly increase the expressiveness of the model, yet
                 they are closed under complementation, making every
                 type of compatibility or replaceability analysis
                 decidable. Finally, we implemented our approach in the
                 context of a larger project called ServiceMosaic, a
                 model-driven framework for Web service life-cycle
                 management.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "compatibility and replaceability analysis; timed
                 automata; timed business protocols; Web services",
}

@Article{Payton:2010:SSA,
  author =       "Jamie Payton and Christine Julien and Gruia-Catalin
                 Roman and Vasanth Rajamani",
  title =        "Semantic self-assessment of query results in dynamic
                 environments",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "4",
  pages =        "12:1--12:??",
  month =        apr,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1734229.1734231",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 21 11:41:14 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Queries are convenient abstractions for the discovery
                 of information and services, as they offer
                 content-based information access. In distributed
                 settings, query semantics are well-defined, for
                 example, queries are often designed to satisfy ACID
                 transactional properties. When query processing is
                 introduced in a dynamic network setting, achieving
                 transactional semantics becomes complex due to the open
                 and unpredictable environment. In this article, we
                 propose a query processing model for mobile ad hoc and
                 sensor networks that is suitable for expressing a wide
                 range of query semantics; the semantics differ in the
                 degree of consistency with which query results reflect
                 the state of the environment during query execution. We
                 introduce several distinct notions of consistency and
                 formally express them in our model. A practical and
                 significant contribution of this article is a protocol
                 for query processing that automatically assesses and
                 adaptively provides an achievable degree of consistency
                 given the operational environment throughout its
                 execution. The protocol attaches an assessment of the
                 achieved guarantee to returned query results, allowing
                 precise reasoning about a query with a range of
                 possible semantics. We evaluate the performance of this
                 protocol and demonstrate the benefits accrued to
                 applications through examples drawn from an industrial
                 application.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "consistency; mobile computing; Query processing",
}

@Article{Chen:2010:VSI,
  author =       "Chunqing Chen and Jin Song Dong and Jun Sun and Andrew
                 Martin",
  title =        "A verification system for interval-based specification
                 languages",
  journal =      j-TOSEM,
  volume =       "19",
  number =       "4",
  pages =        "13:1--13:??",
  month =        apr,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1734229.1734232",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 21 11:41:14 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Interval-based specification languages have been used
                 to formally model and rigorously reason about real-time
                 computing systems. This usually involves logical
                 reasoning and mathematical computation with respect to
                 continuous or discrete time. When these systems are
                 complex, analyzing their models by hand becomes
                 error-prone and difficult. In this article, we develop
                 a verification system to facilitate the formal analysis
                 of interval-based specification languages with
                 machine-assisted proof support. The verification system
                 is developed using a generic theorem prover, Prototype
                 Verification System (PVS). Our system elaborately
                 encodes a highly expressive set-based notation, Timed
                 Interval Calculus (TIC), and can rigorously carry out
                 the verification of TIC models at an interval level. We
                 validated all TIC reasoning rules and discovered subtle
                 flaws in the original rules. We also apply TIC to model
                 Duration Calculus (DC), which is a popular
                 interval-based specification language, and thus expand
                 the capacity of the verification system. We can check
                 the correctness of DC axioms, and execute DC proofs in
                 a manner similar to the corresponding pencil-and-paper
                 DC arguments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Formal specification languages; real-time systems;
                 theorem proving",
}

@Article{Steimann:2010:TMI,
  author =       "Friedrich Steimann and Thomas Pawlitzki and Sven Apel
                 and Christian K{\"a}stner",
  title =        "Types and modularity for implicit invocation with
                 implicit announcement",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jun,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1767751.1767752",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Jul 6 16:17:49 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Through implicit invocation, procedures are called
                 without explicitly referencing them. Implicit
                 announcement adds to this implicitness by not only
                 keeping implicit which procedures are called, but also
                 where or when --- under implicit invocation with
                 implicit announcement, the call site contains no signs
                 of that, or what it calls. Recently, aspect-oriented
                 programming has popularized implicit invocation with
                 implicit announcement as a possibility to separate
                 concerns that lead to interwoven code if conventional
                 programming techniques are used. However, as has been
                 noted elsewhere, as currently implemented it
                 establishes strong implicit dependencies between
                 components, hampering independent software development
                 and evolution. To address this problem, we present a
                 type-based modularization of implicit invocation with
                 implicit announcement that is inspired by how
                 interfaces and exceptions are realized in Java. By
                 extending an existing compiler and by rewriting several
                 programs to make use of our proposed language
                 constructs, we found that the imposed declaration
                 clutter tends to be moderate; in particular, we found
                 that, for general applications of implicit invocation
                 with implicit announcement, fears that programs
                 utilizing our form of modularization become
                 unreasonably verbose are unjustified.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "aspect-oriented programming; event-driven programming;
                 Implicit invocation; modularity; publish/subscribe;
                 typing",
}

@Article{Conboy:2010:MDC,
  author =       "Kieran Conboy and Brian Fitzgerald",
  title =        "Method and developer characteristics for effective
                 agile method tailoring: a study of {XP} expert
                 opinion",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jun,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1767751.1767753",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Jul 6 16:17:49 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "It has long been acknowledged that software methods
                 should be tailored if they are to achieve optimum
                 effect. However comparatively little research has been
                 carried out to date on this topic in general, and more
                 notably, on agile methods in particular. This dearth of
                 evidence in the case of agile methods is especially
                 significant in that it is reasonable to expect that
                 such methods would particularly lend themselves to
                 tailoring. In this research, we present a framework
                 based on interviews with 20 senior software development
                 researchers and a review of the extant literature. The
                 framework is comprised of two sets of factors ---
                 characteristics of the method, and developer practices
                 --- that can improve method tailoring effectiveness.
                 Drawing on the framework, we then interviewed 16 expert
                 XP practitioners to examine the current state and
                 effectiveness of XP tailoring efforts, and to shed
                 light on issues the framework identified as being
                 important. The article concludes with a set of
                 recommendations for research and practice that would
                 advance our understanding of the method tailoring
                 area.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "agile method; contingency; engineering; expert
                 opinion; Extreme programming; software development;
                 tailoring; XP",
}

@Article{Duala-Ekoko:2010:CRD,
  author =       "Ekwa Duala-Ekoko and Martin P. Robillard",
  title =        "Clone region descriptors: {Representing} and tracking
                 duplication in source code",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jun,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1767751.1767754",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Jul 6 16:17:49 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Source code duplication, commonly known as {\em code
                 cloning}, is considered an obstacle to software
                 maintenance because changes to a cloned region often
                 require consistent changes to other regions of the
                 source code. Research has provided evidence that the
                 elimination of clones may not always be practical,
                 feasible, or cost-effective. We present a clone
                 management approach that describes clone regions in a
                 robust way that is independent from the exact text of
                 clone regions or their location in a file, and that
                 provides support for tracking clones in evolving
                 software. Our technique relies on the concept of
                 abstract {\em clone region descriptors\/} (CRDs), which
                 describe clone regions using a combination of their
                 syntactic, structural, and lexical information. We
                 present our definition of CRDs, and describe a clone
                 tracking system capable of producing CRDs from the
                 output of different clone detection tools, notifying
                 developers of modifications to clone regions, and
                 supporting updates to the documented clone
                 relationships. We evaluated the performance and
                 usefulness of our approach across three clone detection
                 tools and five subject systems, and the results
                 indicate that CRDs are a practical and robust
                 representation for tracking code clones in evolving
                 software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "clone detection; clone management; code clones;
                 refactoring; Source code duplication",
}

@Article{Ko:2010:EAW,
  author =       "Andrew J. Ko and Brad A. Myers",
  title =        "Extracting and answering why and why not questions
                 about {Java} program output",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "2",
  pages =        "4:1--4:??",
  month =        aug,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1824760.1824761",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Sep 8 18:47:44 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "When software developers want to understand the reason
                 for a program's behavior, they must translate their
                 questions about the behavior into a series of questions
                 about code, speculating about the causes in the
                 process. The Whyline is a new kind of debugging tool
                 that avoids such speculation by instead enabling
                 developers to select a question about program output
                 from a set of ``why did and why didn't'' questions
                 extracted from the program's code and execution. The
                 tool then finds one or more possible explanations for
                 the output in question. These explanations are derived
                 using a static and dynamic slicing, precise call
                 graphs, reachability analyses, and new algorithms for
                 determining potential sources of values. Evaluations of
                 the tool on two debugging tasks showed that developers
                 with the Whyline were three times more successful and
                 twice as fast at debugging, compared to developers with
                 traditional breakpoint debuggers. The tool has the
                 potential to simplify debugging and program
                 understanding in many software development contexts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "debugging; questions; Whyline",
}

@Article{Sullivan:2010:MAO,
  author =       "Kevin Sullivan and William G. Griswold and Hridesh
                 Rajan and Yuanyuan Song and Yuanfang Cai and Macneil
                 Shonle and Nishit Tewari",
  title =        "Modular aspect-oriented design with {XPIs}",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "2",
  pages =        "5:1--5:??",
  month =        aug,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1824760.1824762",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Sep 8 18:47:44 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The emergence of aspect-oriented programming (AOP)
                 languages has provided software designers with new
                 mechanisms and strategies for decomposing programs into
                 modules and composing modules into systems. What we do
                 not yet fully understand is how best to use such
                 mechanisms consistent with common modularization
                 objectives such as the comprehensibility of programming
                 code, its parallel development, dependability, and ease
                 of change. The main contribution of this work is a new
                 form of information-hiding interface for AOP that we
                 call the crosscut programming interface, or XPI. XPIs
                 abstract crosscutting behaviors and make these
                 abstractions explicit. XPIs can be used, albeit with
                 limited enforcement of interface rules, with existing
                 AOP languages, such as AspectJ. To evaluate our notion
                 of XPIs, we have applied our XPI-based design
                 methodology to a medium-sized network overlay
                 application called Hypercast. A qualitative and
                 quantitative analysis of existing AO design methods and
                 XPI-based design method shows that our approach
                 produces improvements in program comprehensibility, in
                 opportunities for parallel development, and in the ease
                 when code can be developed and changed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "Aspect-oriented programming; design rules; options",
}

@Article{Singh:2010:SWE,
  author =       "Param Vir Singh",
  title =        "The small-world effect: {The} influence of macro-level
                 properties of developer collaboration networks on
                 open-source project success",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "2",
  pages =        "6:1--6:??",
  month =        aug,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1824760.1824763",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Sep 8 18:47:44 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In this study we investigate the impact of
                 community-level networks --- relationships that exist
                 among developers in an OSS community --- on the
                 productivity of member developers. Specifically, we
                 argue that OSS community networks characterized by {\em
                 small-world\/} properties would positively influence
                 the productivity of the member developers by providing
                 them with speedy and reliable access to more quantity
                 and variety of information and knowledge resources.
                 Specific hypotheses are developed and tested using
                 longitudinal data on a large panel of 4,279 projects
                 from 15 different OSS communities hosted at
                 Sourceforge. Our results suggest that significant
                 variation exists in small-world properties of OSS
                 communities at Sourceforge. After accounting for
                 project, foundry, and time-specific observed and
                 unobserved effects, we found a statistically
                 significant relationship between small-world properties
                 of a community and the technical and commercial success
                 of the software produced by its members. In contrast to
                 the findings of prior research, we also found the lack
                 of a significant relationship between closeness and
                 betweenness centralities of the project teams and their
                 success. These results were robust to a number of
                 controls and model specifications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "collaborative software development; online community;
                 Open source software development; productivity; small
                 world networks; social networks; team formation",
}

@Article{Dyer:2010:SDA,
  author =       "Robert Dyer and Hridesh Rajan",
  title =        "Supporting dynamic aspect-oriented features",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "2",
  pages =        "7:1--7:??",
  month =        aug,
  year =         "2010",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/1824760.1824764",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Sep 8 18:47:44 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Dynamic aspect-oriented (AO) features have important
                 software engineering benefits such as allowing
                 unanticipated software evolution and maintenance. It is
                 thus important to efficiently support these features in
                 language implementations. Current implementations incur
                 unnecessary design-time and runtime overhead due to the
                 lack of support in underlying intermediate language
                 (IL) models. To address this problem, we present a
                 flexible and dynamic IL model that we call {\em Nu}.
                 The {\em Nu\/} model provides a higher level of
                 abstraction compared to traditional object-oriented
                 ILs, making it easier to efficiently support dynamic AO
                 features. We demonstrate these benefits by providing an
                 industrial-strength VM implementation for {\em Nu}, by
                 showing translation strategies from dynamic
                 source-level constructs to {\em Nu\/} and by analyzing
                 the performance of the resulting IL code.\par

                 {\em Nu\/}'s VM extends the Sun Hotspot VM interpreter
                 and uses a novel caching mechanism to significantly
                 reduce the amortized costs of join point dispatch. Our
                 evaluation using standard benchmarks shows that the
                 overhead of supporting a dynamic deployment model can
                 be reduced to as little as $ \approx $1.5\%. {\em Nu\/}
                 provides an improved compilation target for dynamic
                 deployment features, which makes it easier to support
                 such features with corresponding software engineering
                 benefits in software evolution and maintenance and in
                 runtime verification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "aspect-oriented intermediate-languages;
                 aspect-oriented virtual machines; invocation; Nu;
                 weaving",
}

@Article{Miles:2011:PMD,
  author =       "Simon Miles and Paul Groth and Steve Munroe and Luc
                 Moreau",
  title =        "{PrIMe}: a methodology for developing provenance-aware
                 applications",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "8:1--8:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000792",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Provenance refers to the past processes that brought
                 about a given (version of an) object, item or entity.
                 By knowing the provenance of data, users can often
                 better understand, trust, reproduce, and validate it. A
                 provenance-aware application has the functionality to
                 answer questions regarding the provenance of the data
                 it produces, by using documentation of past processes.
                 PrIMe is a software engineering technique for adapting
                 application designs to enable them to interact with a
                 provenance middleware layer, thereby making them
                 provenance-aware.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2011:TDB,
  author =       "Jinjun Chen and Yun Yang",
  title =        "Temporal dependency-based checkpoint selection for
                 dynamic verification of temporal constraints in
                 scientific workflow systems",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "9:1--9:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000793",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In a scientific workflow system, a checkpoint
                 selection strategy is used to select checkpoints along
                 scientific workflow execution for verifying temporal
                 constraints so that we can identify any temporal
                 violations and handle them in time in order to ensure
                 overall temporal correctness of the execution that is
                 often essential for the usefulness of execution
                 results. The problem of existing representative
                 strategies is that they do not differentiate temporal
                 constraints as, once a checkpoint is selected, they
                 verify all temporal constraints. However, such a
                 checkpoint does not need to be taken for those
                 constraints whose consistency can be deduced from
                 others. The corresponding verification of such
                 constraints is consequently unnecessary and can
                 severely impact overall temporal verification
                 efficiency while the efficiency determines whether
                 temporal violations can be identified quickly for
                 handling in time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Anvik:2011:REB,
  author =       "John Anvik and Gail C. Murphy",
  title =        "Reducing the effort of bug report triage: Recommenders
                 for development-oriented decisions",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "10:1--10:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000794",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A key collaborative hub for many software development
                 projects is the bug report repository. Although its use
                 can improve the software development process in a
                 number of ways, reports added to the repository need to
                 be triaged. A triager determines if a report is
                 meaningful. Meaningful reports are then organized for
                 integration into the project's development process. To
                 assist triagers with their work, this article presents
                 a machine learning approach to create recommenders that
                 assist with a variety of decisions aimed at
                 streamlining the development process. The recommenders
                 created with this approach are accurate; for instance,
                 recommenders for which developer to assign a report
                 that we have created using this approach have a
                 precision between 70\% and 98\% over five open source
                 projects.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Naish:2011:MSB,
  author =       "Lee Naish and Hua Jie Lee and Kotagiri Ramamohanarao",
  title =        "A model for spectra-based software diagnosis",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "11:1--11:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000795",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article presents an improved approach to assist
                 diagnosis of failures in software (fault localisation)
                 by ranking program statements or blocks in accordance
                 with to how likely they are to be buggy. We present a
                 very simple single-bug program to model the problem. By
                 examining different possible execution paths through
                 this model program over a number of test cases, the
                 effectiveness of different proposed spectral ranking
                 methods can be evaluated in idealised conditions. The
                 results are remarkably consistent to those arrived at
                 empirically using the Siemens test suite and Space
                 benchmarks. The model also helps identify groups of
                 metrics that are equivalent for ranking.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Binkley:2011:FTT,
  author =       "David W. Binkley and Mark Harman and Kiran Lakhotia",
  title =        "{FlagRemover}: a testability transformation for
                 transforming loop-assigned flags",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "12:1--12:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000796",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Search-Based Testing is a widely studied technique for
                 automatically generating test inputs, with the aim of
                 reducing the cost of software engineering activities
                 that rely upon testing. However, search-based
                 approaches degenerate to random testing in the presence
                 of flag variables, because flags create spikes and
                 plateaux in the fitness landscape. Both these features
                 are known to denote hard optimization problems for all
                 search-based optimization techniques. Several authors
                 have studied flag removal transformations and fitness
                 function refinements to address the issue of flags, but
                 the problem of loop-assigned flags remains unsolved.
                 This article introduces a testability transformation
                 along with a tool that transforms programs with
                 loop-assigned flags into flag-free equivalents, so that
                 existing search-based test data generation approaches
                 can successfully be applied.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2011:RFC,
  author =       "Zhenyu Chen and Tsong Yueh Chen and Baowen Xu",
  title =        "A revisit of fault class hierarchies in general
                 {Boolean} specifications",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "3",
  pages =        "13:1--13:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000791.2000797",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 18:32:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Recently, Kapoor and Bowen [2007] have extended the
                 works by Kuhn [1999], Tsuchiya and Kikuno [2002], and
                 Lau and Yu [2005]. However, their proofs overlook the
                 possibility that a mutant of the Boolean specifications
                 under test may be equivalent. Hence, each of their
                 fault relationships is either incorrect or has an
                 incorrect proof. In this article, we give
                 counterexamples to the incorrect fault relationships
                 and provide new proofs for the valid fault
                 relationships. Furthermore, a co-stronger fault
                 relation is introduced to establish a new fault class
                 hierarchy for general Boolean specifications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bauer:2011:RVL,
  author =       "Andreas Bauer and Martin Leucker and Christian
                 Schallhart",
  title =        "Runtime Verification for {LTL} and {TLTL}",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "14:1--14:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000800",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article studies runtime verification of
                 properties expressed either in lineartime temporal
                 logic (LTL) or timed lineartime temporal logic (TLTL).
                 It classifies runtime verification in identifying its
                 distinguishing features to model checking and testing,
                 respectively. It introduces a three-valued semantics
                 (with truth values true, false, inconclusive) as an
                 adequate interpretation as to whether a partial
                 observation of a running system meets an LTL or TLTL
                 property. For LTL, a conceptually simple monitor
                 generation procedure is given, which is optimal in two
                 respects: First, the size of the generated
                 deterministic monitor is minimal, and, second, the
                 monitor identifies a continuously monitored trace as
                 either satisfying or falsifying a property as early as
                 possible.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nie:2011:MFC,
  author =       "Changhai Nie and Hareton Leung",
  title =        "The Minimal Failure-Causing Schema of Combinatorial
                 Testing",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "15:1--15:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000801",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Combinatorial Testing (CT) involves the design of a
                 small test suite to cover the parameter value
                 combinations so as to detect failures triggered by the
                 interactions among these parameters. To make full use
                 of CT and to extend its advantages, this article first
                 gives a model of CT and then presents a theory of the
                 Minimal Failure-causing Schema (MFS), including the
                 concept of the MFS, proof of its existence, some of its
                 properties, and a method of finding the MFS. Then we
                 propose a methodology for CT based on this MFS theory
                 and the existing research. Our MFS-based methodology
                 emphasizes that CT should work on accurate testing
                 requirements, and has the following advantages: (1)
                 Detect failure to the greatest degree with the least
                 cost.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gandhi:2011:DMC,
  author =       "R. A. Gandhi and S. W. Lee",
  title =        "Discovering Multidimensional Correlations among
                 Regulatory Requirements to Understand Risk",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "16:1--16:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000802",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Security breaches most often occur due to a cascading
                 effect of failure among security constraints that
                 collectively contribute to overall secure system
                 behavior in a socio-technical environment. Therefore,
                 during security certification activities, analysts must
                 systematically take into account the nexus of causal
                 chains that exist among security constraints imposed by
                 regulatory requirements. Numerous regulatory
                 requirements specified in natural language documents or
                 listed in spreadsheets/databases do not facilitate such
                 analysis. The work presented in this article outlines a
                 stepwise methodology to discover and understand the
                 multidimensional correlations among regulatory
                 requirements for the purpose of understanding the
                 potential for risk due to noncompliance during system
                 operation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dehlinger:2011:GPP,
  author =       "Josh Dehlinger and Robyn R. Lutz",
  title =        "{Gaia-PL}: a Product Line Engineering Approach for
                 Efficiently Designing Multiagent Systems",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "17:1--17:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000803",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Agent-oriented software engineering (AOSE) has
                 provided powerful and natural, high-level abstractions
                 in which software developers can understand, model and
                 develop complex, distributed systems. Yet, the
                 realization of AOSE partially depends on whether
                 agent-based software systems can achieve reductions in
                 development time and cost similar to other
                 reuse-conscious development methods. Specifically, AOSE
                 does not adequately address requirements specifications
                 as reusable assets. Software product line engineering
                 is a reuse technology that supports the systematic
                 development of a set of similar software systems
                 through understanding, controlling, and managing their
                 common, core characteristics and their differing
                 variation points. In this article, we present an
                 extension to the Gaia AOSE methodology, named Gaia-PL
                 (Gaia-Product Line), for agent-based distributed
                 software systems that enables requirements
                 specifications to be easily reused.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Maoz:2011:CMS,
  author =       "Shahar Maoz and David Harel and Asaf Kleinbort",
  title =        "A Compiler for Multimodal Scenarios: Transforming
                 {LSCs} into {AspectJ}",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "18:1--18:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000804",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We exploit the main similarity between the
                 aspect-oriented programming paradigm and the
                 inter-object, scenario-based approach to specification,
                 in order to construct a new way of executing systems
                 based on the latter. Specifically, we transform
                 multimodal scenario-based specifications, given in the
                 visual language of live sequence charts (LSC), into
                 what we call scenario aspects, implemented in AspectJ.
                 Unlike synthesis approaches, which attempt to take the
                 inter-object scenarios and construct intra-object
                 state-based per-object specifications or a single
                 controller automaton, we follow the ideas behind the
                 LSC play-out algorithm to coordinate the simultaneous
                 monitoring and direct execution of the specified
                 scenarios. Thus, the structure of the specification is
                 reflected in the structure of the generated code; the
                 high-level inter-object requirements and their
                 structure are not lost in the translation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dagenais:2011:RAC,
  author =       "Barth{\'e}l{\'e}my Dagenais and Martin P. Robillard",
  title =        "Recommending Adaptive Changes for Framework
                 Evolution",
  journal =      j-TOSEM,
  volume =       "20",
  number =       "4",
  pages =        "19:1--19:??",
  month =        sep,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2000799.2000805",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 26 17:32:55 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In the course of a framework's evolution, changes
                 ranging from a simple refactoring to a complete
                 rearchitecture can break client programs. Finding
                 suitable replacements for framework elements that were
                 accessed by a client program and deleted as part of the
                 framework's evolution can be a challenging task. We
                 present a recommendation system, SemDiff, that suggests
                 adaptations to client programs by analyzing how a
                 framework was adapted to its own changes. In a study of
                 the evolution of one open source framework and three
                 client programs, our approach recommended relevant
                 adaptive changes with a high level of precision.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ebnenasir:2011:FSD,
  author =       "Ali Ebnenasir and Sandeep S. Kulkarni",
  title =        "Feasibility of Stepwise Design of Multitolerant
                 Programs",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "1:1--1:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063240",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The complexity of designing programs that
                 simultaneously tolerate multiple classes of faults,
                 called multitolerant programs, is in part due to the
                 conflicting nature of the fault tolerance requirements
                 that must be met by a multitolerant program when
                 different types of faults occur. To facilitate the
                 design of multitolerant programs, we present sound and
                 (deterministically) complete algorithms for stepwise
                 design of two families of multitolerant programs in a
                 high atomicity program model, where a process can read
                 and write all program variables in an atomic step. We
                 illustrate that if one needs to design failsafe
                 (respectively, nonmasking) fault tolerance for one
                 class of faults and masking fault tolerance for another
                 class of faults, then a multitolerant program can be
                 designed in separate polynomial-time (in the state
                 space of the fault-intolerant program) steps regardless
                 of the order of addition.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arnold:2011:QER,
  author =       "Matthew Arnold and Martin Vechev and Eran Yahav",
  title =        "{QVM}: An Efficient Runtime for Detecting Defects in
                 Deployed Systems",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "2:1--2:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063241",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Coping with software defects that occur in the
                 post-deployment stage is a challenging problem: bugs
                 may occur only when the system uses a specific
                 configuration and only under certain usage scenarios.
                 Nevertheless, halting production systems until the bug
                 is tracked and fixed is often impossible. Thus,
                 developers have to try to reproduce the bug in
                 laboratory conditions. Often, the reproduction of the
                 bug takes most of the debugging effort. In this paper
                 we suggest an approach to address this problem by using
                 a specialized runtime environment called Quality
                 Virtual Machine (QVM). QVM efficiently detects defects
                 by continuously monitoring the execution of the
                 application in a production setting.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tilevich:2011:EEP,
  author =       "Eli Tilevich and Sriram Gopal",
  title =        "Expressive and Extensible Parameter Passing for
                 Distributed Object Systems",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "3:1--3:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063242",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In modern distributed object systems, reference
                 parameters to a remote method are passed according to
                 their runtime type. This design choice limits the
                 expressiveness, readability, and maintainability of
                 distributed applications. Further, to extend the
                 built-in set of parameter passing semantics of a
                 distributed object system, the programmer has to
                 understand and modify the underlying middleware
                 implementation. To address these design shortcomings,
                 this article presents (i) a declarative and extensible
                 approach to remote parameter passing that decouples
                 parameter passing semantics from parameter types, and
                 (ii) a plugin-based framework, DeXteR, which enables
                 the programmer to extend the built-in set of remote
                 parameter passing semantics, without having to
                 understand or modify the underlying middleware
                 implementation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sim:2011:HWD,
  author =       "Susan Elliott Sim and Medha Umarji and Sukanya
                 Ratanotayanon and Cristina V. Lopes",
  title =        "How Well Do Search Engines Support Code Retrieval on
                 the {Web}?",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "4:1--4:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063243",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software developers search the Web for various kinds
                 of source code for diverse reasons. In a previous
                 study, we found that searches varied along two
                 dimensions: the size of the search target (e.g., block,
                 subsystem, or system) and the motivation for the search
                 (e.g., reference example or as-is reuse). Would each of
                 these kinds of searches require different search
                 technologies? To answer this question, we conducted an
                 experiment with 36 participants to evaluate three
                 diverse approaches (general purpose information
                 retrieval, source code search, and component reuse), as
                 represented by five Web sites (Google, Koders, Krugle,
                 Google Code Search, and SourceForge). The independent
                 variables were search engine, size of search target,
                 and motivation for search.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Diep:2011:LBS,
  author =       "Madeline M. Diep and Matthew B. Dwyer and Sebastian
                 Elbaum",
  title =        "Lattice-Based Sampling for Path Property Monitoring",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "5:1--5:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063244",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Runtime monitoring can provide important insights
                 about a program's behavior and, for simple properties,
                 it can be done efficiently. Monitoring properties
                 describing sequences of program states and events,
                 however, can result in significant runtime overhead.
                 This is particularly critical when monitoring programs
                 deployed at user sites that have low tolerance for
                 overhead. In this paper we present a novel approach to
                 reducing the cost of runtime monitoring of path
                 properties. A set of original properties are composed
                 to form a single integrated property that is then
                 systematically decomposed into a set of properties that
                 encode necessary conditions for property violations.
                 The resulting set of properties forms a lattice whose
                 structure is exploited to select a sample of properties
                 that can lower monitoring cost, while preserving
                 violation detection power relative to the original
                 properties.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Erwig:2011:CCR,
  author =       "Martin Erwig and Eric Walkingshaw",
  title =        "The Choice Calculus: a Representation for Software
                 Variation",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "1",
  pages =        "6:1--6:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2063239.2063245",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Dec 20 18:31:08 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many areas of computer science are concerned with some
                 form of variation in software---from managing changes
                 to software over time to supporting families of related
                 artifacts. We present the choice calculus, a
                 fundamental representation for software variation that
                 can serve as a common language of discourse for
                 variation research, filling a role similar to the
                 lambda calculus in programming language research. We
                 also develop an associated theory of software
                 variation, including sound transformations of variation
                 artifacts, the definition of strategic normal forms,
                 and a design theory for variation structures, which
                 will support the development of better algorithms and
                 tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Notkin:2012:E,
  author =       "David Notkin",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "7:1--7:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089117",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{AlDallal:2012:PMM,
  author =       "Jehad {Al Dallal} and Lionel C. Briand",
  title =        "A Precise Method-Method Interaction-Based Cohesion
                 Metric for Object-Oriented Classes",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "8:1--8:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089118",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The building of highly cohesive classes is an
                 important objective in object-oriented design. Class
                 cohesion refers to the relatedness of the class
                 members, and it indicates one important aspect of the
                 class design quality. A meaningful class cohesion
                 metric helps object-oriented software developers detect
                 class design weaknesses and refactor classes
                 accordingly. Several class cohesion metrics have been
                 proposed in the literature. Most of these metrics are
                 applicable based on low-level design information such
                 as attribute references in methods. Some of these
                 metrics capture class cohesion by counting the number
                 of method pairs that share common attributes. A few
                 metrics measure cohesion more precisely by considering
                 the degree of interaction, through attribute
                 references, between each pair of methods. However, the
                 formulas applied by these metrics to measure the degree
                 of interaction cause the metrics to violate important
                 mathematical properties, thus undermining their
                 construct validity and leading to misleading cohesion
                 measurement. In this paper, we propose a formula that
                 precisely measures the degree of interaction between
                 each pair of methods, and we use it as a basis to
                 introduce a low-level design class cohesion metric
                 (LSCC). We verify that the proposed formula does not
                 cause the metric to violate important mathematical
                 properties. In addition, we provide a mechanism to use
                 this metric as a useful indicator for refactoring
                 weakly cohesive classes, thus showing its usefulness in
                 improving class cohesion. Finally, we empirically
                 validate LSCC. Using four open source software systems
                 and eleven cohesion metrics, we investigate the
                 relationship between LSCC, other cohesion metrics, and
                 fault occurrences in classes. Our results show that
                 LSCC is one of three metrics that explains more
                 accurately the presence of faults in classes. LSCC is
                 the only one among the three metrics to comply with
                 important mathematical properties, and statistical
                 analysis shows it captures a measurement dimension of
                 its own. This suggests that LSCC is a better
                 alternative, when taking into account both theoretical
                 and empirical results, as a measure to guide the
                 refactoring of classes. From a more general standpoint,
                 the results suggest that class quality, as measured in
                 terms of fault occurrences, can be more accurately
                 explained by cohesion metrics that account for the
                 degree of interaction between each pair of methods.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fischbein:2012:WAM,
  author =       "Dario Fischbein and Nicolas D'Ippolito and Greg Brunet
                 and Marsha Chechik and Sebastian Uchitel",
  title =        "Weak Alphabet Merging of Partial Behavior Models",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "9:1--9:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089119",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Constructing comprehensive operational models of
                 intended system behavior is a complex and costly task,
                 which can be mitigated by the construction of partial
                 behavior models, providing early feedback and
                 subsequently elaborating them iteratively. However, how
                 should partial behavior models with different
                 viewpoints covering different aspects of behavior be
                 composed? How should partial models of component
                 instances of the same type be put together? In this
                 article, we propose model merging of modal transition
                 systems (MTSs) as a solution to these questions. MTS
                 models are a natural extension of labelled transition
                 systems that support explicit modeling of what is
                 currently unknown about system behavior. We formally
                 define model merging based on weak alphabet refinement,
                 which guarantees property preservation, and show that
                 merging consistent models is a process that should
                 result in a minimal common weak alphabet refinement
                 (MCR). In this article, we provide theoretical results
                 and algorithms that support such a process. Finally,
                 because in practice MTS merging is likely to be
                 combined with other operations over MTSs such as
                 parallel composition, we also study the algebraic
                 properties of merging and apply these, together with
                 the algorithms that support MTS merging, in a case
                 study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mattsson:2012:AMA,
  author =       "Anders Mattsson and Brian Fitzgerald and Bj{\"o}rn
                 Lundell and Brian Lings",
  title =        "An Approach for Modeling Architectural Design Rules in
                 {UML} and its Application to Embedded Software",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "10:1--10:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089120",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Current techniques for modeling software architecture
                 do not provide sufficient support for modeling
                 architectural design rules. This is a problem in the
                 context of model-driven development in which it is
                 assumed that major design artifacts are represented as
                 formal or semi-formal models. This article addresses
                 this problem by presenting an approach to modeling
                 architectural design rules in UML at the abstraction
                 level of the meaning of the rules. The high abstraction
                 level and the use of UML makes the rules both amenable
                 to automation and easy to understand for both
                 architects and developers, which is crucial to
                 deployment in an organization. To provide a
                 proof-of-concept, a tool was developed that validates a
                 system model against the architectural rules in a
                 separate UML model. To demonstrate the feasibility of
                 the approach, the architectural design rules of an
                 existing live industrial-strength system were modeled
                 according to the approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kulkarni:2012:GPF,
  author =       "Devdatta Kulkarni and Tanvir Ahmed and Anand
                 Tripathi",
  title =        "A Generative Programming Framework for Context-Aware
                 {CSCW} Applications",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "11:1--11:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089121",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present a programming framework based on the
                 paradigm of generative application development for
                 building context-aware collaborative applications. In
                 this approach, context-aware applications are
                 implemented using a domain-specific design model, and
                 their execution environment is generated and maintained
                 by the middleware. The key features of this design
                 model include support for context-based service
                 discovery and binding, context-based access control,
                 context-based multiuser coordination, and
                 context-triggered automated task executions. The
                 middleware uses the technique of policy-based
                 specialization for generating application-specific
                 middleware components from the generic middleware
                 components. Through a case-study example, we
                 demonstrate this approach and present the evaluations
                 of the design model and the middleware.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Roychoudhury:2012:SMS,
  author =       "Abhik Roychoudhury and Ankit Goel and Bikram
                 Sengupta",
  title =        "Symbolic Message Sequence Charts",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "12:1--12:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089122",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Message sequence charts (MSCs) are a widely used
                 visual formalism for scenario-based specifications of
                 distributed reactive systems. In its conventional
                 usage, an MSC captures an interaction snippet between
                 concrete objects in the system. This leads to
                 voluminous specifications when the system contains
                 several objects that are behaviorally similar. MSCs
                 also play an important role in the model-based testing
                 of reactive systems, where they may be used for
                 specifying (partial) system behaviors, describing test
                 generation criteria, or representing test cases.
                 However, since the number of processes in a MSC
                 specification are fixed, model-based testing of systems
                 consisting of process classes may involve a significant
                 amount of rework: for example, reconstructing system
                 models, or regenerating test cases for systems
                 differing only in the number of processes of various
                 types. In this article we propose a scenario-based
                 notation, called symbolic message sequence charts
                 (SMSCs), for modeling, simulation, and testing of
                 process classes. SMSCs are a lightweight syntactic and
                 semantic extension of MSCs where, unlike MSCs, a SMSC
                 lifeline can denote some/all objects from a collection.
                 Our extensions give us substantially more modeling
                 power. Moreover, we present an abstract execution
                 semantics for (structured collections of) SMSCs. This
                 allows us to validate MSC-based system models capturing
                 interactions between large, or even unbounded, number
                 of objects. Finally, we describe a SMSC-based testing
                 methodology for process classes, which allows
                 generation of test cases for new object configurations
                 with minimal rework. Since our SMSC extensions are only
                 concerned with MSC lifelines, we believe that they can
                 be integrated into existing standards such as UML 2.0.
                 We illustrate our SMSC-based framework for modeling,
                 simulation, and testing of process classes using a
                 weather-update controller case-study from NASA.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Queralt:2012:VVU,
  author =       "Anna Queralt and Ernest Teniente",
  title =        "Verification and Validation of {UML} Conceptual
                 Schemas with {OCL} Constraints",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "2",
  pages =        "13:1--13:??",
  month =        mar,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2089116.2089123",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Mar 19 17:14:21 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "To ensure the quality of an information system, it is
                 essential that the conceptual schema that represents
                 the knowledge about its domain is semantically correct.
                 The semantic correctness of a conceptual schema can be
                 seen from two different perspectives. On the one hand,
                 from the point of view of its definition, a conceptual
                 schema must be right. This is ensured by means of
                 verification techniques that check whether the schema
                 satisfies several correctness properties. On the other
                 hand, from the point of view of the requirements that
                 the information system should satisfy, a schema must
                 also be the right one. This is ensured by means of
                 validation techniques, which help the designer
                 understand the exact meaning of a schema and to see
                 whether it corresponds to the requirements. In this
                 article we propose an approach to verify and validate
                 UML conceptual schemas, with arbitrary constraints
                 formalized in OCL. We have also implemented our
                 approach to show its feasibility.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kastner:2012:TCA,
  author =       "Christian K{\"a}stner and Sven Apel and Thomas
                 Th{\"u}m and Gunter Saake",
  title =        "Type checking annotation-based product lines",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "14:1--14:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211617",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software product line engineering is an efficient
                 means of generating a family of program variants for a
                 domain from a single code base. However, because of the
                 potentially high number of possible program variants,
                 it is difficult to test them all and ensure properties
                 like type safety for the entire product line. We
                 present a product-line-aware type system that can type
                 check an entire software product line without
                 generating each variant in isolation. Specifically, we
                 extend the Featherweight Java calculus with feature
                 annotations for product-line development and prove
                 formally that all program variants generated from a
                 well typed product line are well typed. Furthermore, we
                 present a solution to the problem of typing mutually
                 exclusive features. We discuss how results from our
                 formalization helped implement our own product-line
                 tool CIDE for full Java and report of our experience
                 with detecting type errors in four existing software
                 product line implementations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shonle:2012:FCR,
  author =       "Macneil Shonle and William G. Griswold and Sorin
                 Lerner",
  title =        "A framework for the checking and refactoring of
                 crosscutting concepts",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "15:1--15:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211618",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Programmers employ crosscutting concepts, such as
                 design patterns and other programming idioms, when
                 their design ideas cannot be efficiently or effectively
                 modularized in the underlying programming language. As
                 a result, implementations of these crosscutting
                 concepts can be hard to change even when the code is
                 well structured. In this article, we describe Arcum, a
                 system that supports the modular maintenance of
                 crosscutting concepts. Arcum can be used to both check
                 essential constraints of crosscutting concepts and to
                 substitute crosscutting concept implementations with
                 alternative implementations. Arcum is complementary to
                 existing refactoring systems that focus on
                 meaning-preserving program transformations at the
                 programming-language-semantics level, because Arcum
                 focuses on transformations at the conceptual level. We
                 present the underpinnings of the Arcum approach and
                 show how Arcum can be used to address several classical
                 software engineering problems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fantechi:2012:LVM,
  author =       "Alessandro Fantechi and Stefania Gnesi and Alessandro
                 Lapadula and Franco Mazzanti and Rosario Pugliese and
                 Francesco Tiezzi",
  title =        "A logical verification methodology for
                 service-oriented computing",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "16:1--16:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211619",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We introduce a logical verification methodology for
                 checking behavioral properties of service-oriented
                 computing systems. Service properties are described by
                 means of SocL, a branching-time temporal logic that we
                 have specifically designed for expressing in an
                 effective way distinctive aspects of services, such as,
                 acceptance of a request, provision of a response,
                 correlation among service requests and responses, etc.
                 Our approach allows service properties to be expressed
                 in such a way that they can be independent of service
                 domains and specifications. We show an instantiation of
                 our general methodology that uses the formal language
                 COWS to conveniently specify services and the expressly
                 developed software tool CMC to assist the user in the
                 task of verifying SocL formulas over service
                 specifications. We demonstrate the feasibility and
                 effectiveness of our methodology by means of the
                 specification and analysis of a case study in the
                 automotive domain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Strecker:2012:ADC,
  author =       "Jaymie Strecker and Atif M. Memon",
  title =        "Accounting for defect characteristics in evaluations
                 of testing techniques",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "17:1--17:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211620",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "As new software-testing techniques are developed,
                 before they can achieve widespread acceptance, their
                 effectiveness at detecting defects must be evaluated.
                 The most common way of evaluating testing techniques is
                 with empirical studies, in which one or more techniques
                 are tried out on software with known defects. However,
                 the defects used can affect the performance of the
                 techniques. To complicate matters, it is not even clear
                 how to effectively describe or characterize defects. To
                 address these problems, this article describes an
                 experiment architecture for empirically evaluating
                 testing techniques which takes both defect and
                 test-suite characteristics into account. As proof of
                 concept, an experiment on GUI-testing techniques is
                 conducted. It provides evidence that the defect
                 characteristics proposed do help explain defect
                 detection, at least for GUI testing, and it explores
                 the relationship between the coverage of defective code
                 and the detection of defects.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jennings:2012:TPA,
  author =       "Paul Jennings and Arka P. Ghosh and Samik Basu",
  title =        "A two-phase approximation for model checking
                 probabilistic unbounded until properties of
                 probabilistic systems",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "18:1--18:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211621",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We have developed a new approximate probabilistic
                 model-checking method for untimed properties in
                 probabilistic systems, expressed in a probabilistic
                 temporal logic (PCTL, CSL). This method, in contrast to
                 the existing ones, does not require the untimed until
                 properties to be bounded a priori, where the bound
                 refers to the number of discrete steps in the system
                 required to verify the until property. The method
                 consists of two phases. In the first phase, a suitable
                 system- and property-dependent bound $ k_0 $ is
                 obtained automatically. In the second phase, the
                 probability of satisfying the $ k_0$-bounded until
                 property is computed as the estimate of the probability
                 of satisfying the original unbounded until property.
                 Both phases require only verification of bounded until
                 properties, which can be effectively performed by
                 simulation-based methods. We prove the correctness of
                 the proposed two-phase method and present its optimized
                 implementation in the widely used PRISM model-checking
                 engine. We compare this implementation with
                 sampling-based model-checking techniques implemented in
                 two tools: PRISM and MRMC. We show that for several
                 models these existing tools fail to compute the result,
                 while the two-phase method successfully computes the
                 result efficiently with respect to time and space.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Qi:2012:DAD,
  author =       "Dawei Qi and Abhik Roychoudhury and Zhenkai Liang and
                 Kapil Vaswani",
  title =        "{DARWIN}: an approach to debugging evolving programs",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "3",
  pages =        "19:1--19:??",
  month =        jun,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2211616.2211622",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 29 18:08:30 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Bugs in programs are often introduced when programs
                 evolve from a stable version to a new version. In this
                 article, we propose a new approach called DARWIN for
                 automatically finding potential root causes of such
                 bugs. Given two programs --- a reference program and a
                 modified program --- and an input that fails on the
                 modified program, our approach uses symbolic execution
                 to automatically synthesize a new input that (a) is
                 very similar to the failing input and (b) does not
                 fail. We find the potential cause(s) of failure by
                 comparing control-flow behavior of the passing and
                 failing inputs and identifying code fragments where the
                 control flows diverge. A notable feature of our
                 approach is that it handles hard-to-explain bugs, like
                 code missing errors, by pointing to code in the
                 reference program. We have implemented this approach
                 and conducted experiments using several real-world
                 applications, such as the Apache Web server, libPNG (a
                 library for manipulating PNG images), and TCPflow (a
                 program for displaying data sent through TCP
                 connections). In each of these applications, DARWIN was
                 able to localize bugs with high accuracy. Even though
                 these applications contain several thousands of lines
                 of code, DARWIN could usually narrow down the potential
                 root cause(s) to less than ten lines. In addition, we
                 find that the inputs synthesized by DARWIN provide
                 additional value by revealing other undiscovered
                 errors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Holmes:2012:SPS,
  author =       "Reid Holmes and Robert J. Walker",
  title =        "Systematizing pragmatic software reuse",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "20:1--20:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377657",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many software reuse tasks involve reusing source code
                 that was not designed in a manner conducive to those
                 tasks, requiring that ad hoc modifications be applied.
                 Such pragmatic reuse tasks are a reality in disciplined
                 industrial practice; they arise for a variety of
                 organizational and technical reasons. To investigate a
                 pragmatic reuse task, a developer must navigate
                 through, and reason about, source code dependencies in
                 order to identify program elements that are relevant to
                 the task and to decide how those elements should be
                 reused. The developer must then convert his mental
                 model of the task into a set of actions that he can
                 perform. These steps are poorly supported by modern
                 development tools and practices. We provide a model for
                 the process involved in performing a pragmatic reuse
                 task, including the need to capture (mentally or
                 otherwise) the developer's decisions about how each
                 program element should be treated: this is a
                 pragmatic-reuse plan. We provide partial support for
                 this model via a tool suite, called Gilligan; other
                 parts of the model are supported via standard IDE
                 tools. Using a pragmatic-reuse plan, Gilligan can
                 semiautomatically transform the selected source code
                 from its originating system and integrate it into the
                 developer's system. We have evaluated Gilligan through
                 a series of case studies and experiments (each
                 involving industrial developers) using a variety of
                 source systems and tasks; we report in particular on a
                 previously unpublished, formal experiment. The results
                 show that pragmatic-reuse plans are a robust metaphor
                 for capturing pragmatic reuse intent and that, relative
                 to standard IDE tools, Gilligan can (1) significantly
                 decrease the time that developers require to perform
                 pragmatic reuse tasks, (2) increase the likelihood that
                 developers will successfully complete pragmatic reuse
                 tasks, (3) decrease the time required by developers to
                 identify infeasible reuse tasks, and (4) improve
                 developers' sense of their ability to manage the risk
                 in such tasks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cai:2012:FMA,
  author =       "Yuanfang Cai and Kevin Sullivan",
  title =        "A formal model for automated software modularity and
                 evolvability analysis",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "21:1--21:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377658",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Neither the nature of modularity in software design,
                 characterized as a property of the structure of
                 dependencies among design decisions, or its economic
                 value are adequately well understood. One basic problem
                 is that we do not even have a sufficiently clear
                 definition of what it means for one design decision to
                 depend on another. The main contribution of this work
                 is one possible mathematically precise definition of
                 dependency based on an augmented constraint network
                 model. The model provides an end-to-end account of the
                 connection between modularity and its value in terms of
                 options to make adaptive changes in uncertain and
                 changing design spaces. We demonstrate the validity and
                 theoretical utility of the model, showing that it is
                 consistent with, and provides new insights into,
                 several previously published results in design
                 theory.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cimatti:2012:VRH,
  author =       "Alessandro Cimatti and Marco Roveri and Angelo Susi
                 and Stefano Tonetta",
  title =        "Validation of requirements for hybrid systems: a
                 formal approach",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "22:1--22:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377659",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Flaws in requirements may have unacceptable
                 consequences in the development of safety-critical
                 applications. Formal approaches may help with a deep
                 analysis that takes care of the precise semantics of
                 the requirements. However, the proposed solutions often
                 disregard the problem of integrating the formalization
                 with the analysis, and the underlying logical framework
                 lacks either expressive power, or automation. We
                 propose a new, comprehensive approach for the
                 validation of functional requirements of hybrid
                 systems, where discrete components and continuous
                 components are tightly intertwined. The proposed
                 solution allows to tackle problems of conversion from
                 informal to formal, traceability, automation, user
                 acceptance, and scalability. We build on a new
                 language, othello which is expressive enough to
                 represent various domains of interest, yet allowing
                 efficient procedures for checking the satisfiability.
                 Around this, we propose a structured methodology where:
                 informal requirements are fragmented and categorized
                 according to their role; each fragment is formalized
                 based on its category; specialized formal analysis
                 techniques, optimized for requirements analysis, are
                 finally applied. The approach was the basis of an
                 industrial project aiming at the validation of the
                 European Train Control System (ETCS) requirements
                 specification. During the project a realistic subset of
                 the ETCS specification was formalized and analyzed. The
                 approach was positively assessed by domain experts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Poshyvanyk:2012:CLU,
  author =       "Denys Poshyvanyk and Malcom Gethers and Andrian
                 Marcus",
  title =        "Concept location using formal concept analysis and
                 information retrieval",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "23:1--23:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377660",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The article addresses the problem of concept location
                 in source code by proposing an approach that combines
                 Formal Concept Analysis and Information Retrieval. In
                 the proposed approach, Latent Semantic Indexing, an
                 advanced Information Retrieval approach, is used to map
                 textual descriptions of software features or bug
                 reports to relevant parts of the source code, presented
                 as a ranked list of source code elements. Given the
                 ranked list, the approach selects the most relevant
                 attributes from the best ranked documents, clusters the
                 results, and presents them as a concept lattice,
                 generated using Formal Concept Analysis. The approach
                 is evaluated through a large case study on concept
                 location in the source code on six open-source systems,
                 using several hundred features and bugs. The empirical
                 study focuses on the analysis of various configurations
                 of the generated concept lattices and the results
                 indicate that our approach is effective in organizing
                 different concepts and their relationships present in
                 the subset of the search results. In consequence, the
                 proposed concept location method has been shown to
                 outperform a standalone Information Retrieval based
                 concept location technique by reducing the number of
                 irrelevant search results across all the systems and
                 lattice configurations evaluated, potentially reducing
                 the programmers' effort during software maintenance
                 tasks involving concept location.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Meneely:2012:VSM,
  author =       "Andrew Meneely and Ben Smith and Laurie Williams",
  title =        "Validating software metrics: a spectrum of
                 philosophies",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "24:1--24:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377661",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Context. Researchers proposing a new metric have the
                 burden of proof to demonstrate to the research
                 community that the metric is acceptable in its intended
                 use. This burden of proof is provided through the
                 multi-faceted, scientific, and objective process of
                 software metrics validation. Over the last 40 years,
                 however, researchers have debated what constitutes a
                 ``valid'' metric. Aim. The debate over what constitutes
                 a valid metric centers on software metrics validation
                 criteria. The objective of this article is to guide
                 researchers in making sound contributions to the field
                 of software engineering metrics by providing a
                 practical summary of the metrics validation criteria
                 found in the academic literature. Method. We conducted
                 a systematic literature review that began with 2,288
                 papers and ultimately focused on 20 papers. After
                 extracting 47 unique validation criteria from these 20
                 papers, we performed a comparative analysis to explore
                 the relationships amongst the criteria. Results. Our 47
                 validation criteria represent a diverse view of what
                 constitutes a valid metric. We present an analysis of
                 the criteria's categorization, conflicts, common
                 themes, and philosophical motivations behind the
                 validation criteria. Conclusions. Although the 47
                 validation criteria are not conflict-free, the
                 diversity of motivations and philosophies behind the
                 validation criteria indicates that metrics validation
                 is complex. Researchers proposing new metrics should
                 consider the applicability of the validation criteria
                 in terms of our categorization and analysis. Rather
                 than arbitrarily choosing validation criteria for each
                 metric, researchers should choose criteria that can
                 confirm that the metric is appropriate for its intended
                 use. We conclude that metrics validation criteria
                 provide answers to questions that researchers have
                 about the merits and limitations of a metric.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kiezun:2012:HSW,
  author =       "Adam Kiezun and Vijay Ganesh and Shay Artzi and Philip
                 J. Guo and Pieter Hooimeijer and Michael D. Ernst",
  title =        "{HAMPI}: a solver for word equations over strings,
                 regular expressions, and context-free grammars",
  journal =      j-TOSEM,
  volume =       "21",
  number =       "4",
  pages =        "25:1--25:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2377656.2377662",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 2 06:46:47 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many automatic testing, analysis, and verification
                 techniques for programs can be effectively reduced to a
                 constraint-generation phase followed by a
                 constraint-solving phase. This separation of concerns
                 often leads to more effective and maintainable software
                 reliability tools. The increasing efficiency of
                 off-the-shelf constraint solvers makes this approach
                 even more compelling. However, there are few effective
                 and sufficiently expressive off-the-shelf solvers for
                 string constraints generated by analysis of
                 string-manipulating programs, so researchers end up
                 implementing their own ad-hoc solvers. To fulfill this
                 need, we designed and implemented Hampi, a solver for
                 string constraints over bounded string variables. Users
                 of Hampi specify constraints using regular expressions,
                 context-free grammars, equality between string terms,
                 and typical string operations such as concatenation and
                 substring extraction. Hampi then finds a string that
                 satisfies all the constraints or reports that the
                 constraints are unsatisfiable. We demonstrate Hampi's
                 expressiveness and efficiency by applying it to program
                 analysis and automated testing. We used Hampi in static
                 and dynamic analyses for finding SQL injection
                 vulnerabilities in Web applications with hundreds of
                 thousands of lines of code. We also used Hampi in the
                 context of automated bug finding in C programs using
                 dynamic systematic testing (also known as concolic
                 testing). We then compared Hampi with another string
                 solver, CFGAnalyzer, and show that Hampi is several
                 times faster. Hampi's source code, documentation, and
                 experimental data are available at
                 \path=http://people.csail.mit.edu/akiezun/hampi=",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Notkin:2013:ELB,
  author =       "David Notkin",
  title =        "Editorial --- looking back",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2431201",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2013:ELF,
  author =       "David S. Rosenblum",
  title =        "Editorial --- looking forward",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "2:1--2:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2431202",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2013:MVH,
  author =       "Jun Sun and Yang Liu and Jin Song Dong and Yan Liu and
                 Ling Shi and {\'E}tienne Andr{\'e}",
  title =        "Modeling and verifying hierarchical real-time systems
                 using stateful timed {CSP}",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "3:1--3:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430537",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Modeling and verifying complex real-time systems are
                 challenging research problems. The de facto approach is
                 based on Timed Automata, which are finite state
                 automata equipped with clock variables. Timed Automata
                 are deficient in modeling hierarchical complex systems.
                 In this work, we propose a language called Stateful
                 Timed CSP and an automated approach for verifying
                 Stateful Timed CSP models. Stateful Timed CSP is based
                 on Timed CSP and is capable of specifying hierarchical
                 real-time systems. Through dynamic zone abstraction,
                 finite-state zone graphs can be generated automatically
                 from Stateful Timed CSP models, which are subject to
                 model checking. Like Timed Automata, Stateful Timed CSP
                 models suffer from Zeno runs, that is, system runs that
                 take infinitely many steps within finite time. Unlike
                 Timed Automata, model checking with non-Zenoness in
                 Stateful Timed CSP can be achieved based on the zone
                 graphs. We extend the PAT model checker to support
                 system modeling and verification using Stateful Timed
                 CSP and show its usability/scalability via verification
                 of real-world systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Demsky:2013:VSF,
  author =       "Brian Demsky and Patrick Lam",
  title =        "Views: {Synthesizing} fine-grained concurrency
                 control",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "4:1--4:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430538",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Fine-grained locking is often necessary to increase
                 concurrency. Correctly implementing fine-grained
                 locking with today's concurrency primitives can be
                 challenging-race conditions often plague programs with
                 sophisticated locking schemes. We present views, a new
                 approach to concurrency control. Views ease the task of
                 implementing sophisticated locking schemes and provide
                 static checks to automatically detect many data races.
                 A view of an object declares a partial interface,
                 consisting of fields and methods, to the object that
                 the view protects. A view also contains an
                 incompatibility declaration, which lists views that may
                 not be simultaneously held by other threads. A set of
                 view annotations specify which code regions hold a view
                 of an object. Our view compiler performs simple static
                 checks that identify many data races. We pair the basic
                 approach with an inference algorithm that can infer
                 view incompatibility specifications for many
                 applications. We have ported four benchmark
                 applications to use views: portions of Vuze, a
                 BitTorrent client; Mailpuccino, a graphical email
                 client; jphonelite, a VoIP softphone implementation;
                 and TupleSoup, a database. Our experience indicates
                 that views are easy to use, make implementing
                 sophisticated locking schemes simple, and can help
                 eliminate concurrency bugs. We have evaluated the
                 performance of a view implementation of a red-black
                 tree and found that views can significantly improve
                 performance over that of the lock-based
                 implementation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yue:2013:FTU,
  author =       "Tao Yue and Lionel C. Briand and Yvan Labiche",
  title =        "Facilitating the transition from use case models to
                 analysis models: Approach and experiments",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "5:1--5:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430539",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Use case modeling, including use case diagrams and use
                 case specifications (UCSs), is commonly applied to
                 structure and document requirements. UCSs are usually
                 structured but unrestricted textual documents complying
                 with a certain use case template. However, because Use
                 Case Models (UCMods) remain essentially textual,
                 ambiguity is inevitably introduced. In this article, we
                 propose a use case modeling approach, called Restricted
                 Use Case Modeling (RUCM), which is composed of a set of
                 well-defined restriction rules and a modified use case
                 template. The goal is two-fold: (1) restrict the way
                 users can document UCSs in order to reduce ambiguity
                 and (2) facilitate the manual derivation of initial
                 analysis models which, when using the Unified Modeling
                 Language (UML), are typically composed of class
                 diagrams, sequence diagrams, and possibly other types
                 of diagrams. Though the proposed restriction rules and
                 template are based on a clear rationale, two main
                 questions need to be investigated. First, do users find
                 them too restrictive or impractical in certain
                 situations? In other words, can users express the same
                 requirements with RUCM as with unrestricted use cases?
                 Second, do the rules and template have a positive,
                 significant impact on the quality of the constructed
                 analysis models? To investigate these questions, we
                 performed and report on two controlled experiments,
                 which evaluate the restriction rules and use case
                 template in terms of (1) whether they are easy to apply
                 while developing UCMods and facilitate the
                 understanding of UCSs, and (2) whether they help users
                 manually derive higher quality analysis models than
                 what can be generated when they are not used, in terms
                 of correctness, completeness, and redundancy. This
                 article reports on the first controlled experiments
                 that evaluate the applicability of restriction rules on
                 use case modeling and their impact on the quality of
                 analysis models. The measures we have defined to
                 characterize restriction rules and the quality of
                 analysis class and sequence diagrams can be reused to
                 perform similar experiments in the future, either with
                 RUCM or other approaches. Results show that the
                 restriction rules are overall easy to apply and that
                 RUCM results into significant improvements over
                 traditional approaches (i.e., with standard templates,
                 without restrictions) in terms of class correctness and
                 class diagram completeness, message correctness and
                 sequence diagram completeness, and understandability of
                 UCSs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hemmati:2013:ASM,
  author =       "Hadi Hemmati and Andrea Arcuri and Lionel Briand",
  title =        "Achieving scalable model-based testing through test
                 case diversity",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "6:1--6:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430540",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The increase in size and complexity of modern software
                 systems requires scalable, systematic, and automated
                 testing approaches. Model-based testing (MBT), as a
                 systematic and automated test case generation
                 technique, is being successfully applied to verify
                 industrial-scale systems and is supported by commercial
                 tools. However, scalability is still an open issue for
                 large systems, as in practice there are limits to the
                 amount of testing that can be performed in industrial
                 contexts. Even with standard coverage criteria, the
                 resulting test suites generated by MBT techniques can
                 be very large and expensive to execute, especially for
                 system level testing on real deployment platforms and
                 network facilities. Therefore, a scalable MBT technique
                 should be flexible regarding the size of the generated
                 test suites and should be easily accommodated to fit
                 resource and time constraints. Our approach is to
                 select a subset of the generated test suite in such a
                 way that it can be realistically executed and analyzed
                 within the time and resource constraints, while
                 preserving the fault revealing power of the original
                 test suite to a maximum extent. In this article, to
                 address this problem, we introduce a family of
                 similarity-based test case selection techniques for
                 test suites generated from state machines. We evaluate
                 320 different similarity-based selection techniques and
                 then compare the effectiveness of the best
                 similarity-based selection technique with other common
                 selection techniques in the literature. The results
                 based on two industrial case studies, in the domain of
                 embedded systems, show significant benefits and a large
                 improvement in performance when using a
                 similarity-based approach. We complement these analyses
                 with further studies on the scalability of the
                 technique and the effects of failure rate on its
                 effectiveness. We also propose a method to identify
                 optimal tradeoffs between the number of test cases to
                 run and fault detection.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Monperrus:2013:DMM,
  author =       "Martin Monperrus and Mira Mezini",
  title =        "Detecting missing method calls as violations of the
                 majority rule",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "7:1--7:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430541",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "When using object-oriented frameworks it is easy to
                 overlook certain important method calls that are
                 required at particular places in code. In this article,
                 we provide a comprehensive set of empirical facts on
                 this problem, starting from traces of missing method
                 calls in a bug repository. We propose a new system that
                 searches for missing method calls in software based on
                 the other method calls that are observable. Our key
                 insight is that the voting theory concept of majority
                 rule holds for method calls: a call is likely to be
                 missing if there is a majority of similar pieces of
                 code where this call is present. The evaluation shows
                 that the system predictions go further missing method
                 calls and often reveal different kinds of code smells
                 (e.g., violations of API best practices).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2013:SPA,
  author =       "Jeff Huang and Jinguo Zhou and Charles Zhang",
  title =        "Scaling predictive analysis of concurrent programs by
                 removing trace redundancy",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "8:1--8:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430542",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Predictive trace analysis (PTA) of concurrent programs
                 is powerful in finding concurrency bugs unseen in past
                 program executions. Unfortunately, existing PTA
                 solutions face considerable challenges in scaling to
                 large traces. In this article, we identify that a large
                 percentage of events in the trace are redundant for
                 presenting useful analysis results to the end user.
                 Removing them from the trace can significantly improve
                 the scalability of PTA without affecting the quality of
                 the results. We present a trace redundancy theorem that
                 specifies a redundancy criterion and the soundness
                 guarantee that the PTA results are preserved after
                 removing the redundancy. Based on this criterion, we
                 design and implement TraceFilter, an efficient
                 algorithm that automatically removes redundant events
                 from a trace for the PTA of general concurrency access
                 anomalies. We evaluated TraceFilter on a set of popular
                 concurrent benchmarks as well as real world large
                 server programs. Our experimental results show that
                 TraceFilter is able to significantly improve the
                 scalability of PTA by orders of magnitude, without
                 impairing the analysis result.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dippolito:2013:SNE,
  author =       "Nicol{\'a}s D'ippolito and Victor Braberman and Nir
                 Piterman and Sebasti{\'a}n Uchitel",
  title =        "Synthesizing nonanomalous event-based controllers for
                 liveness goals",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "1",
  pages =        "9:1--9:??",
  month =        feb,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430536.2430543",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Mar 2 09:22:48 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present SGR(1), a novel synthesis technique and
                 methodological guidelines for automatically
                 constructing event-based behavior models. Our approach
                 works for an expressive subset of liveness properties,
                 distinguishes between controlled and monitored actions,
                 and differentiates system goals from environment
                 assumptions. We show that assumptions must be modeled
                 carefully in order to avoid synthesizing anomalous
                 behavior models. We characterize nonanomalous models
                 and propose assumption compatibility, a sufficient
                 condition, as a methodological guideline.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2013:CDC,
  author =       "Wei Zhang and Chong Sun and Junghee Lim and Shan Lu
                 and Thomas Reps",
  title =        "{ConMem}: Detecting Crash-Triggering Concurrency Bugs
                 through an Effect-Oriented Approach",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "10:1--10:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430546",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Multicore technology is making concurrent programs
                 increasingly pervasive. Unfortunately, it is difficult
                 to deliver reliable concurrent programs, because of the
                 huge and nondeterministic interleaving space. In
                 reality, without the resources to thoroughly check the
                 interleaving space, critical concurrency bugs can slip
                 into production versions and cause failures in the
                 field. Approaches to making the best use of the limited
                 resources and exposing severe concurrency bugs before
                 software release would be desirable. Unlike previous
                 work that focuses on bugs caused by specific
                 interleavings (e.g., races and atomicity violations),
                 this article targets concurrency bugs that result in
                 one type of severe effect: program crashes. Our study
                 of the error-propagation process of real-world
                 concurrency bugs reveals a common pattern (50\% in our
                 nondeadlock concurrency bug set) that is highly
                 correlated with program crashes. We call this pattern
                 concurrency-memory bugs: buggy interleavings directly
                 cause memory bugs (NULL-pointer-dereferences,
                 dangling-pointers, buffer-overflows,
                 uninitialized-reads) on shared memory objects. Guided
                 by this study, we built ConMem to monitor program
                 execution, analyze memory accesses and
                 synchronizations, and predictively detect these common
                 and severe concurrency-memory bugs. We also built a
                 validator,ConMem-v, to automatically prune false
                 positives by enforcing potential bug-triggering
                 interleavings. We evaluated ConMem using 7 open-source
                 programs with 10 real-world concurrency bugs. ConMem
                 detects more tested bugs (9 out of 10 bugs) than a
                 lock-set-based race detector and an
                 unserializable-interleaving detector, which detect 4
                 and 6 bugs, respectively, with a false-positive rate
                 about one tenth of the compared tools. ConMem-v further
                 prunes out all the false positives. ConMem has
                 reasonable overhead suitable for development usage.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosa:2013:BPM,
  author =       "Marcello {La Rosa} and Marlon Dumas and Reina Uba and
                 Remco Dijkman",
  title =        "Business Process Model Merging: An Approach to
                 Business Process Consolidation",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "11:1--11:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430547",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article addresses the problem of constructing
                 consolidated business process models out of collections
                 of process models that share common fragments. The
                 article considers the construction of unions of
                 multiple models (called merged models ) as well as
                 intersections (called digests ). Merged models are
                 intended for analysts who wish to create a model that
                 subsumes a collection of process models --- typically
                 representing variants of the same underlying process
                 --- with the aim of replacing the variants with the
                 merged model. Digests, on the other hand, are intended
                 for analysts who wish to identify the most recurring
                 fragments across a collection of process models, so
                 that they can focus their efforts on optimizing these
                 fragments. The article presents an algorithm for
                 computing merged models and an algorithm for extracting
                 digests from a merged model. The merging and digest
                 extraction algorithms have been implemented and tested
                 against collections of process models taken from
                 multiple application domains. The tests show that the
                 merging algorithm produces compact models and scales up
                 to process models containing hundreds of nodes.
                 Furthermore, a case study conducted in a large
                 insurance company has demonstrated the usefulness of
                 the merging and digest extraction operators in a
                 practical setting.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zheng:2013:PRP,
  author =       "Zibin Zheng and Michael R. Lyu",
  title =        "Personalized Reliability Prediction of {Web}
                 Services",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "12:1--12:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430548",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Service Oriented Architecture (SOA) is a
                 business-centric IT architectural approach for building
                 distributed systems. Reliability of service-oriented
                 systems heavily depends on the remote Web services as
                 well as the unpredictable Internet connections.
                 Designing efficient and effective reliability
                 prediction approaches of Web services has become an
                 important research issue. In this article, we propose
                 two personalized reliability prediction approaches of
                 Web services, that is, neighborhood-based approach and
                 model-based approach. The neighborhood-based approach
                 employs past failure data of similar neighbors (either
                 service users or Web services) to predict the Web
                 service reliability. On the other hand, the model-based
                 approach fits a factor model based on the available Web
                 service failure data and use this factor model to make
                 further reliability prediction. Extensive experiments
                 are conducted with our real-world Web service datasets,
                 which include about 23 millions invocation results on
                 more than 3,000 real-world Web services. The
                 experimental results show that our proposed reliability
                 prediction approaches obtain better reliability
                 prediction accuracy than other competing approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Walkinshaw:2013:ACS,
  author =       "Neil Walkinshaw and Kirill Bogdanov",
  title =        "Automated Comparison of State-Based Software Models in
                 Terms of Their Language and Structure",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "13:1--13:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430549",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "State machines capture the sequential behavior of
                 software systems. Their intuitive visual notation,
                 along with a range of powerful verification and testing
                 techniques render them an important part of the
                 model-driven software engineering process. There are
                 several situations that require the ability to identify
                 and quantify the differences between two state machines
                 (e.g. to evaluate the accuracy of state machine
                 inference techniques is measured by the similarity of a
                 reverse-engineered model to its reference model). State
                 machines can be compared from two complementary
                 perspectives: (1) In terms of their language --- the
                 externally observable sequences of events that are
                 permitted or not, and (2) in terms of their structure
                 --- the actual states and transitions that govern the
                 behavior. This article describes two techniques to
                 compare models in terms of these two perspectives. It
                 shows how the difference can be quantified and measured
                 by adapting existing binary classification performance
                 measures for the purpose. The approaches have been
                 implemented by the authors, and the implementation is
                 openly available. Feasibility is demonstrated via a
                 case study to compare two real state machine inference
                 approaches. Scalability and accuracy are assessed
                 experimentally with respect to a large collection of
                 randomly synthesized models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fleming:2013:IFT,
  author =       "Scott D. Fleming and Chris Scaffidi and David
                 Piorkowski and Margaret Burnett and Rachel Bellamy and
                 Joseph Lawrance and Irwin Kwan",
  title =        "An Information Foraging Theory Perspective on Tools
                 for Debugging, Refactoring, and Reuse Tasks",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "14:1--14:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430551",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Theories of human behavior are an important but
                 largely untapped resource for software engineering
                 research. They facilitate understanding of human
                 developers' needs and activities, and thus can serve as
                 a valuable resource to researchers designing software
                 engineering tools. Furthermore, theories abstract
                 beyond specific methods and tools to fundamental
                 principles that can be applied to new situations.
                 Toward filling this gap, we investigate the
                 applicability and utility of Information Foraging
                 Theory (IFT) for understanding information-intensive
                 software engineering tasks, drawing upon literature in
                 three areas: debugging, refactoring, and reuse. In
                 particular, we focus on software engineering tools that
                 aim to support information-intensive activities, that
                 is, activities in which developers spend time seeking
                 information. Regarding applicability, we consider
                 whether and how the mathematical equations within IFT
                 can be used to explain why certain existing tools have
                 proven empirically successful at helping software
                 engineers. Regarding utility, we applied an IFT
                 perspective to identify recurring design patterns in
                 these successful tools, and consider what opportunities
                 for future research are revealed by our IFT
                 perspective.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chaki:2013:VAI,
  author =       "Sagar Chaki and Christian Schallhart and Helmut
                 Veith",
  title =        "Verification across Intellectual Property Boundaries",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "2",
  pages =        "15:1--15:??",
  month =        mar,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2430545.2430550",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Mar 27 05:43:25 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In many industries, the importance of software
                 components provided by third-party suppliers is
                 steadily increasing. As the suppliers seek to secure
                 their intellectual property (IP) rights, the customer
                 usually has no direct access to the suppliers' source
                 code, and is able to enforce the use of verification
                 tools only by legal requirements. In turn, the supplier
                 has no means to convince the customer about successful
                 verification without revealing the source code. This
                 article presents an approach to resolve the conflict
                 between the IP interests of the supplier and the
                 quality interests of the customer. We introduce a
                 protocol in which a dedicated server (called the
                 ``amanat'') is controlled by both parties: the customer
                 controls the verification task performed by the amanat,
                 while the supplier controls the communication channels
                 of the amanat to ensure that the amanat does not leak
                 information about the source code. We argue that the
                 protocol is both practically useful and mathematically
                 sound. As the protocol is based on well-known (and
                 relatively lightweight) cryptographic primitives, it
                 allows a straightforward implementation on top of
                 existing verification tool chains. To substantiate our
                 security claims, we establish the correctness of the
                 protocol by cryptographic reduction proofs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2013:MDN,
  author =       "David S. Rosenblum",
  title =        "In memoriam: {David Notkin} (1955--2013)",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "16:1--16:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491510",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2013:PML,
  author =       "Guoqing Xu and Atanas Rountev",
  title =        "Precise memory leak detection for {Java} software
                 using container profiling",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "17:1--17:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491511",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A memory leak in a Java program occurs when object
                 references that are no longer needed are unnecessarily
                 maintained. Such leaks are difficult to detect because
                 static analysis typically cannot precisely identify
                 these redundant references, and existing dynamic leak
                 detection tools track and report fine-grained
                 information about individual objects, producing results
                 that are usually hard to interpret and lack precision.
                 In this article we introduce a novel container-based
                 heap-tracking technique, based on the fact that many
                 memory leaks in Java programs occur due to incorrect
                 uses of containers, leading to containers that keep
                 references to unused data entries. The novelty of the
                 described work is twofold: (1) instead of tracking
                 arbitrary objects and finding leaks by analyzing
                 references to unused objects, the technique tracks only
                 containers and directly identifies the source of the
                 leak, and (2) the technique computes a confidence value
                 for each container based on a combination of its memory
                 consumption and its elements' staleness (time since
                 last retrieval), while previous approaches do not
                 consider such combined metrics. Our experimental
                 results show that the reports generated by the proposed
                 technique can be very precise: for two bugs reported by
                 Sun, a known bug in SPECjbb 2000, and an example bug
                 from IBM developerWorks, the top containers in the
                 reports include the containers that leak memory.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Le:2013:MDF,
  author =       "Wei Le and Mary Lou Soffa",
  title =        "{Marple}: {Detecting} faults in path segments using
                 automatically generated analyses",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "18:1--18:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491512",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Generally, a fault is a property violation at a
                 program point along some execution path. To obtain the
                 path where a fault occurs, we can either run the
                 program or manually identify the execution paths
                 through code inspection. In both of the cases, only a
                 very limited number of execution paths can be examined
                 for a program. This article presents a static
                 framework, Marple, that automatically detects path
                 segments where a fault occurs at a whole program scale.
                 An important contribution of the work is the design of
                 a demand-driven analysis that effectively addresses
                 scalability challenges faced by traditional
                 path-sensitive fault detection. The techniques are made
                 general via a specification language and an algorithm
                 that automatically generates path-based analyses from
                 specifications. The generality is achieved in handling
                 both data- and control-centric faults as well as both
                 liveness and safety properties, enabling the
                 exploitation of fault interactions for diagnosis and
                 efficiency. Our experimental results demonstrate the
                 effectiveness of our techniques in detecting path
                 segments of buffer overflows, integer violations,
                 null-pointer dereferences, and memory leaks. Because we
                 applied an interprocedural, path-sensitive analysis,
                 our static fault detectors generally report better
                 precision than the tools available for comparison. Our
                 demand-driven analyses are shown scalable to deployed
                 applications such as apache, putty, and ffmpeg.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yoo:2013:FLP,
  author =       "Shin Yoo and Mark Harman and David Clark",
  title =        "Fault localization prioritization: Comparing
                 information-theoretic and coverage-based approaches",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "19:1--19:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491513",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Test case prioritization techniques seek to maximize
                 early fault detection. Fault localization seeks to use
                 test cases already executed to help find the fault
                 location. There is a natural interplay between the two
                 techniques; once a fault is detected, we often switch
                 focus to fault fixing, for which localization may be a
                 first step. In this article we introduce the Fault
                 Localization Prioritization (FLP) problem, which
                 combines prioritization and localization. We evaluate
                 three techniques: a novel FLP technique based on
                 information theory, FLINT (Fault Localization using
                 INformation Theory), that we introduce in this article,
                 a standard Test Case Prioritization (TCP) technique,
                 and a ``test similarity technique'' used in previous
                 work. Our evaluation uses five different releases of
                 four software systems. The results indicate that FLP
                 and TCP can statistically significantly reduce fault
                 localization costs for 73\% and 76\% of cases,
                 respectively, and that FLINT significantly outperforms
                 similarity-based localization techniques in 52\% of the
                 cases considered in the study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pradella:2013:BSC,
  author =       "Matteo Pradella and Angelo Morzenti and Pierluigi {San
                 Pietro}",
  title =        "Bounded satisfiability checking of metric temporal
                 logic specifications",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "20:1--20:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491514",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We introduce bounded satisfiability checking, a
                 verification technique that extends bounded model
                 checking by allowing also the analysis of a descriptive
                 model, consisting of temporal logic formulae, instead
                 of the more customary operational model, consisting of
                 a state transition system. We define techniques for
                 encoding temporal logic formulae into Boolean logic
                 that support the use of bi-infinite time domain and of
                 metric time operators. In the framework of bounded
                 satisfiability checking, we show how a descriptive
                 model can be refined into an operational one, and how
                 the correctness of such a refinement can be verified
                 for the bounded case, setting the stage for a stepwise
                 system development method based on a bounded model
                 refinement. Finally, we show how the adoption of a
                 modular approach can make the bounded refinement
                 process more manageable and efficient. All introduced
                 concepts are extensively applied to a set of case
                 studies, and thoroughly experimented through Zot, our
                 SAT solver-based verification toolset.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Falessi:2013:VDR,
  author =       "Davide Falessi and Lionel C. Briand and Giovanni
                 Cantone and Rafael Capilla and Philippe Kruchten",
  title =        "The value of design rationale information",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "21:1--21:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491515",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A complete and detailed (full) Design Rationale
                 Documentation (DRD) could support many software
                 development activities, such as an impact analysis or a
                 major redesign. However, this is typically too onerous
                 for systematic industrial use as it is not cost
                 effective to write, maintain, or read. The key idea
                 investigated in this article is that DRD should be
                 developed only to the extent required to support
                 activities particularly difficult to execute or in need
                 of significant improvement in a particular context. The
                 aim of this article is to empirically investigate the
                 customization of the DRD by documenting only the
                 information items that will probably be required for
                 executing an activity. This customization strategy
                 relies on the hypothesis that the value of a specific
                 DRD information item depends on its category (e.g.,
                 assumptions, related requirements, etc.) and on the
                 activity it is meant to support. We investigate this
                 hypothesis through two controlled experiments involving
                 a total of 75 master students as experimental subjects.
                 Results show that the value of a DRD information item
                 significantly depends on its category and, within a
                 given category, on the activity it supports.
                 Furthermore, on average among activities, documenting
                 only the information items that have been required at
                 least half of the time (i.e., the information that will
                 probably be required in the future) leads to a
                 customized DRD containing about half the information
                 items of a full documentation. We expect that such a
                 significant reduction in DRD information should
                 mitigate the effects of some inhibitors that currently
                 prevent practitioners from documenting design decision
                 rationale.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hoffman:2013:TOM,
  author =       "Kevin Hoffman and Patrick Eugster",
  title =        "Trading obliviousness for modularity with cooperative
                 aspect-oriented programming",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "22:1--22:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491516",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The potential of aspect-oriented programming to
                 adequately capture crosscutting concerns has yet to be
                 fully realized. For example, authors have detailed
                 significant challenges in creating reusable aspect
                 component libraries. One proposed solution is to
                 introduce Explicit Join Points (EJPs) to increase
                 modularity by reducing obliviousness, enabling a
                 Cooperative Aspect-Oriented Programming (Co-AOP)
                 methodology where base code and aspects synergistically
                 collaborate. This article explores the trade-offs
                 between obliviousness and modularity. We briefly
                 introduce EJPs and Co-AOP, and hypothesize how to
                 balance obliviousness and modularity using Co-AOP. We
                 build upon a prior empirical study to refactor three
                 real-life Java applications to implement the exception
                 handling concern using three distinct strategies: (1)
                 using fully oblivious aspects in AspectJ, (2) using
                 EJPs in a fully explicit fashion, and (3) using EJPs
                 while following the Co-AOP methodology. We study other
                 crosscutting concerns by refactoring a fourth
                 application, JHotDraw. The differences in terms of
                 common code metrics are analyzed, and the impact on
                 modularity is assessed using design structure matrices.
                 Results indicate that the Co-AOP methodology can in
                 many cases significantly improve code quality
                 attributes versus fully oblivious or fully explicit
                 approaches. We conclude with guiding principles on the
                 proper use of EJPs within the Co-AOP methodology.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhu:2013:ADP,
  author =       "Hong Zhu and Ian Bayley",
  title =        "An algebra of design patterns",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "23:1--23:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491517",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In a pattern-oriented software design process, design
                 decisions are made by selecting and instantiating
                 appropriate patterns, and composing them together. In
                 our previous work, we enabled these decisions to be
                 formalized by defining a set of operators on patterns
                 with which instantiations and compositions can be
                 represented. In this article, we investigate the
                 algebraic properties of these operators. We provide and
                 prove a complete set of algebraic laws so that
                 equivalence between pattern expressions can be proven.
                 Furthermore, we define an always-terminating
                 normalization of pattern expression to a canonical form
                 which is unique modulo equivalence in first-order
                 logic. By a case study, the pattern-oriented design of
                 an extensible request-handling framework, we
                 demonstrate two practical applications of the algebraic
                 framework. First, we can prove the correctness of a
                 finished design with respect to the design decisions
                 made and the formal specification of the patterns.
                 Second, we can even derive the design from these
                 components.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Balaban:2013:FSU,
  author =       "Mira Balaban and Azzam Maraee",
  title =        "Finite satisfiability of {UML} class diagrams with
                 constrained class hierarchy",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "24:1--24:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491518",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Models lie at the heart of the emerging model-driven
                 engineering approach. In order to guarantee precise,
                 consistent, and correct models, there is a need for
                 efficient powerful methods for verifying model
                 correctness. Class diagram is the central language
                 within UML. Its correctness problems involve issues of
                 contradiction, namely the consistency problem, and
                 issues of finite instantiation, namely the finite
                 satisfiability problem. This article analyzes the
                 problem of finite satisfiability of class diagrams with
                 class hierarchy constraints and generalization-set
                 constraints. The article introduces the FiniteSat
                 algorithm for efficient detection of finite
                 satisfiability in such class diagrams, and analyzes its
                 limitations in terms of complex hierarchy structures.
                 FiniteSat is strengthened in two directions. First, an
                 algorithm for identification of the cause for a finite
                 satisfiability problem is introduced. Second, a method
                 for propagation of generalization-set constraints in a
                 class diagram is introduced. The propagation method
                 serves as a preprocessing step that improves FiniteSat
                 performance, and helps developers in clarifying
                 intended constraints. These algorithms are implemented
                 in the FiniteSatUSE tool [BGU Modeling Group 2011b], as
                 part of our ongoing effort for constructing a
                 model-level integrated development environment [BGU
                 Modeling Group 2010a].",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DeCaso:2013:EBP,
  author =       "Guido {De Caso} and Victor Braberman and Diego
                 Garbervetsky and Sebastian Uchitel",
  title =        "Enabledness-based program abstractions for behavior
                 validation",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "25:1--25:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491519",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Code artifacts that have nontrivial requirements with
                 respect to the ordering in which their methods or
                 procedures ought to be called are common and appear,
                 for instance, in the form of API implementations and
                 objects. This work addresses the problem of validating
                 if API implementations provide their intended behavior
                 when descriptions of this behavior are informal,
                 partial, or nonexistent. The proposed approach
                 addresses this problem by generating abstract behavior
                 models which resemble typestates. These models are
                 statically computed and encode all admissible sequences
                 of method calls. The level of abstraction at which such
                 models are constructed has shown to be useful for
                 validating code artifacts and identifying findings
                 which led to the discovery of bugs, adjustment of the
                 requirements expected by the engineer to the
                 requirements implicit in the code, and the improvement
                 of available documentation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Marin:2013:UFS,
  author =       "Beatriz Mar{\'\i}n and Giovanni Giachetti and Oscar
                 Pastor and Tanja E. J. Vos and Alain Abran",
  title =        "Using a functional size measurement procedure to
                 evaluate the quality of models in {MDD} environments",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "26:1--26:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491520",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Models are key artifacts in Model-Driven Development
                 (MDD) methods. To produce high-quality software by
                 using MDD methods, quality assurance of models is of
                 paramount importance. To evaluate the quality of
                 models, defect detection is considered a suitable
                 approach and is usually applied using reading
                 techniques. However, these reading techniques have
                 limitations and constraints, and new techniques are
                 required to improve the efficiency at finding as many
                 defects as possible. This article presents a case study
                 that has been carried out to evaluate the use of a
                 Functional Size Measurement (FSM) procedure in the
                 detection of defects in models of an MDD environment.
                 To do this, we compare the defects and the defect types
                 found by an inspection group with the defects and the
                 defect types found by the FSM procedure. The results
                 indicate that the FSM is useful since it finds all the
                 defects related to a specific defect type, it finds
                 different defect types than an inspection group, and it
                 finds defects related to the correctness and the
                 consistency of the models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sinnig:2013:UCT,
  author =       "Daniel Sinnig and Patrice Chalin and Ferhat Khendek",
  title =        "Use case and task models: an integrated development
                 methodology and its formal foundation",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "3",
  pages =        "27:1--27:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491509.2491521",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Jul 27 08:26:00 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "User Interface (UI) development methods are poorly
                 integrated with standard software engineering practice.
                 The differences in terms of artifacts involved,
                 development philosophies, and lifecycles can often
                 result in inconsistent system and UI specifications
                 leading to duplication of effort and increased
                 maintenance costs. To address such shortcomings, we
                 propose an integrated development methodology for use
                 case and task models. Use cases are generally used to
                 capture functional requirements whereas task models
                 specify the detailed user interactions with the UI. Our
                 methodology can assist practitioners in developing
                 software processes which allow these two kinds of
                 artifacts to be developed in a codependent and
                 integrated manner. We present our methodology, describe
                 its semantic foundations along with a set of formal
                 conformance relations, and introduce an automated
                 verification tool.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Denaro:2013:TAA,
  author =       "Giovanni Denaro and Mauro Pezz{\`e} and Davide Tosi",
  title =        "Test-and-adapt: an approach for improving service
                 interchangeability",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "28:1--28:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522921",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Service-oriented applications do not fully benefit
                 from standard APIs yet, and many applications fail to
                 use interchangeably all the services that implement a
                 standard service API. This article presents an approach
                 to develop adaptation strategies that improve service
                 interchangeability for service-oriented applications
                 based on standard APIs. In our approach, an adaptation
                 strategy consists of sets of parametric adaptation
                 plans (called test-and-adapt plans), which execute test
                 cases to reveal the occurrence of interchangeability
                 problems, and activate runtime adaptors according to
                 the test results. Throughout this article, we formalize
                 the structure of the parametric test-and-adapt plans
                 and of their execution semantics, present an algorithm
                 for identifying correct execution orders through sets
                 of test-and-adapt plans, provide empirical evidence of
                 the occurrence of interchangeability problems for
                 sample applications and services, and discuss the
                 effectiveness of the approach in terms of avoided
                 failures, runtime overheads and development costs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Martignoni:2013:MTC,
  author =       "Lorenzo Martignoni and Roberto Paleari and Alessandro
                 Reina and Giampaolo Fresi Roglia and Danilo Bruschi",
  title =        "A methodology for testing {CPU} emulators",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "29:1--29:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522922",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A CPU emulator is a software system that simulates a
                 hardware CPU. Emulators are widely used by computer
                 scientists for various kind of activities (e.g.,
                 debugging, profiling, and malware analysis). Although
                 no theoretical limitation prevents developing an
                 emulator that faithfully emulates a physical CPU,
                 writing a fully featured emulator is a very challenging
                 and error prone task. Modern CISC architectures have a
                 very rich instruction set, some instructions lack
                 proper specifications, and others may have undefined
                 effects in corner cases. This article presents a
                 testing methodology specific for CPU emulators, based
                 on fuzzing. The emulator is ``stressed'' with specially
                 crafted test cases, to verify whether the CPU is
                 properly emulated or not. Improper behaviors of the
                 emulator are detected by running the same test case
                 concurrently on the emulated and on the physical CPUs
                 and by comparing the state of the two after the
                 execution. Differences in the final state testify
                 defects in the code of the emulator. We implemented
                 this methodology in a prototype (named as EmuFuzzer),
                 analyzed five state-of-the-art IA-32 emulators (QEMU,
                 Valgrind, Pin, BOCHS, and JPC), and found several
                 defects in each of them, some of which can prevent
                 proper execution of programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chang:2013:EHH,
  author =       "Herv{\'e} Chang and Leonardo Mariani and Mauro
                 Pezz{\`e}",
  title =        "Exception handlers for healing component-based
                 systems",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "30:1--30:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522923",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "To design effective exception handlers, developers
                 must predict at design time the exceptional events that
                 may occur at runtime, and must implement the
                 corresponding handlers on the basis of their
                 predictions. Designing exception handlers for
                 component-based software systems is particularly
                 difficult because the information required to build
                 handlers is distributed between component and
                 application developers. Component developers know the
                 internal details of the components but ignore the
                 applications, while application developers own the
                 applications but cannot access the details required to
                 implement handlers in components. This article
                 addresses the problem of automatically healing the
                 infield failures that are caused by faulty integration
                 of OTS components. In the article, we propose a
                 technique and a methodology to decouple the tasks of
                 component and application developers, who will be able
                 to share information asynchronously and independently,
                 and communicate implicitly by developing and deploying
                 what we call healing connectors. Component developers
                 implement healing connectors on the basis of
                 information about the integration problems frequently
                 experienced by application developers. Application
                 developers easily and safely install healing connectors
                 in their applications without knowing the internal
                 details of the connectors. Healing connectors heal
                 failures activated by exceptions raised in the OTS
                 components actually deployed in the system. The article
                 defines healing connectors, introduces a methodology to
                 develop and deploy healing connectors, and presents
                 several case studies that indicate that healing
                 connectors are effective, reusable and efficient.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xie:2013:TAR,
  author =       "Xiaoyuan Xie and Tsong Yueh Chen and Fei-Ching Kuo and
                 Baowen Xu",
  title =        "A theoretical analysis of the risk evaluation formulas
                 for spectrum-based fault localization",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "31:1--31:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522924",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "An important research area of Spectrum-Based Fault
                 Localization (SBFL) is the effectiveness of risk
                 evaluation formulas. Most previous studies have adopted
                 an empirical approach, which can hardly be considered
                 as sufficiently comprehensive because of the huge
                 number of combinations of various factors in SBFL.
                 Though some studies aimed at overcoming the limitations
                 of the empirical approach, none of them has provided a
                 completely satisfactory solution. Therefore, we provide
                 a theoretical investigation on the effectiveness of
                 risk evaluation formulas. We define two types of
                 relations between formulas, namely, equivalent and
                 better. To identify the relations between formulas, we
                 develop an innovative framework for the theoretical
                 investigation. Our framework is based on the concept
                 that the determinant for the effectiveness of a formula
                 is the number of statements with risk values higher
                 than the risk value of the faulty statement. We group
                 all program statements into three disjoint sets with
                 risk values higher than, equal to, and lower than the
                 risk value of the faulty statement, respectively. For
                 different formulas, the sizes of their sets are
                 compared using the notion of subset. We use this
                 framework to identify the maximal formulas which should
                 be the only formulas to be used in SBFL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Qi:2013:PEB,
  author =       "Dawei Qi and Hoang D. T. Nguyen and Abhik
                 Roychoudhury",
  title =        "Path exploration based on symbolic output",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "32:1--32:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522925",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Efficient program path exploration is important for
                 many software engineering activities such as testing,
                 debugging, and verification. However, enumerating all
                 paths of a program is prohibitively expensive. In this
                 article, we develop a partitioning of program paths
                 based on the program output. Two program paths are
                 placed in the same partition if they derive the output
                 similarly, that is, the symbolic expression connecting
                 the output with the inputs is the same in both paths.
                 Our grouping of paths is gradually created by a smart
                 path exploration. Our experiments show the benefits of
                 the proposed path exploration in test-suite
                 construction. Our path partitioning produces a semantic
                 signature of a program-describing all the different
                 symbolic expressions that the output can assume along
                 different program paths. To reason about changes
                 between program versions, we can therefore analyze
                 their semantic signatures. In particular, we
                 demonstrate the applications of our path partitioning
                 in testing and debugging of software regressions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tateishi:2013:PIS,
  author =       "Takaaki Tateishi and Marco Pistoia and Omer Tripp",
  title =        "Path- and index-sensitive string analysis based on
                 monadic second-order logic",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "33:1--33:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522926",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/string-matching.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We propose a novel technique for statically verifying
                 the strings generated by a program. The verification is
                 conducted by encoding the program in Monadic
                 Second-order Logic (M2L). We use M2L to describe
                 constraints among program variables and to abstract
                 built-in string operations. Once we encode a program in
                 M2L, a theorem prover for M2L, such as MONA, can
                 automatically check if a string generated by the
                 program satisfies a given specification, and if not,
                 exhibit a counterexample. With this approach, we can
                 naturally encode relationships among strings,
                 accounting also for cases in which a program
                 manipulates strings using indices. In addition, our
                 string analysis is path sensitive in that it accounts
                 for the effects of string and Boolean comparisons, as
                 well as regular-expression matches. We have implemented
                 our string analysis algorithm, and used it to augment
                 an industrial security analysis for Web applications by
                 automatically detecting and verifying sanitizers ---
                 methods that eliminate malicious patterns from
                 untrusted strings, making these strings safe to use in
                 security-sensitive operations. On the 8 benchmarks we
                 analyzed, our string analyzer discovered 128 previously
                 unknown sanitizers, compared to 71 sanitizers detected
                 by a previously presented string analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Vouillon:2013:SCC,
  author =       "J{\'e}r{\^o}me Vouillon and Roberto {Di Cosmo}",
  title =        "On software component co-installability",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "34:1--34:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522927",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Modern software systems are built by composing
                 components drawn from large repositories, whose size
                 and complexity is increasing at a very fast pace. A
                 fundamental challenge for the maintainability and the
                 scalability of such software systems is the ability to
                 quickly identify the components that can or cannot be
                 installed together: this is the co-installability
                 problem, which is related to boolean satisfiability and
                 is known to be algorithmically hard. This article
                 develops a novel theoretical framework, based on
                 formally certified semantic preserving graph-theoretic
                 transformations, that allows us to associate to each
                 concrete component repository a much smaller one with a
                 simpler structure, that we call strongly flat, with
                 equivalent co-installability properties. This flat
                 repository can be displayed in a way that provides a
                 concise view of the co-installability issues in the
                 original repository, or used as a basis for various
                 algorithms related to co-installability, like the
                 efficient computation of strong conflicts between
                 components. The proofs contained in this work have been
                 machine checked using the Coq proof assistant.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Minku:2013:SEE,
  author =       "Leandro L. Minku and Xin Yao",
  title =        "Software effort estimation as a multiobjective
                 learning problem",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "35:1--35:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522928",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Ensembles of learning machines are promising for
                 software effort estimation (SEE), but need to be
                 tailored for this task to have their potential
                 exploited. A key issue when creating ensembles is to
                 produce diverse and accurate base models. Depending on
                 how differently different performance measures behave
                 for SEE, they could be used as a natural way of
                 creating SEE ensembles. We propose to view SEE model
                 creation as a multiobjective learning problem. A
                 multiobjective evolutionary algorithm (MOEA) is used to
                 better understand the tradeoff among different
                 performance measures by creating SEE models through the
                 simultaneous optimisation of these measures. We show
                 that the performance measures behave very differently,
                 presenting sometimes even opposite trends. They are
                 then used as a source of diversity for creating SEE
                 ensembles. A good tradeoff among different measures can
                 be obtained by using an ensemble of MOEA solutions.
                 This ensemble performs similarly or better than a model
                 that does not consider these measures explicitly.
                 Besides, MOEA is also flexible, allowing emphasis of a
                 particular measure if desired. In conclusion, MOEA can
                 be used to better understand the relationship among
                 performance measures and has shown to be very effective
                 in creating SEE models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lizcano:2013:WCA,
  author =       "David Lizcano and Fernando Alonso and Javier Soriano
                 and Genoveva Lopez",
  title =        "A web-centred approach to end-user software
                 engineering",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "36:1--36:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522929",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article addresses one of the major end-user
                 software engineering (EUSE) challenges, namely, how to
                 motivate end users to apply unfamiliar software
                 engineering techniques and activities to achieve their
                 goal: translate requirements into software that meets
                 their needs. EUSE activities are secondary to the goal
                 that the program is helping to achieve and end-user
                 programming is opportunistic. The challenge is then to
                 find ways to incorporate EUSE activities into the
                 existing workflow without users having to make
                 substantial changes to the type of work they do or
                 their priorities. In this article, we set out an
                 approach to EUSE for web-based applications. We also
                 propose a software lifecycle that is consistent with
                 the conditions and priorities of end users without
                 programming skills and is well-aligned with EUSE's
                 characteristic informality, ambiguity and
                 opportunisticness. Users applying this lifecycle manage
                 to find solutions that they would otherwise be unable
                 to identify. They also develop quality products. Users
                 of this approach will not have to be acquainted with
                 software engineering, as a framework will take them
                 through the web-centred EUSE lifecycle step-by-step. We
                 also report a statistical experiment in which users
                 develop web software with and without a framework to
                 guide them through the lifecycle. Its aim is to
                 validate the applicability of our framework-driven
                 lifecycle.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mcmillan:2013:PSR,
  author =       "Collin Mcmillan and Denys Poshyvanyk and Mark
                 Grechanik and Qing Xie and Chen Fu",
  title =        "{Portfolio}: Searching for relevant functions and
                 their usages in millions of lines of code",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "37:1--37:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522930",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/pagerank.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Different studies show that programmers are more
                 interested in finding definitions of functions and
                 their uses than variables, statements, or ordinary code
                 fragments. Therefore, developers require support in
                 finding relevant functions and determining how these
                 functions are used. Unfortunately, existing code search
                 engines do not provide enough of this support to
                 developers, thus reducing the effectiveness of code
                 reuse. We provide this support to programmers in a code
                 search system called Portfolio that retrieves and
                 visualizes relevant functions and their usages. We have
                 built Portfolio using a combination of models that
                 address surfing behavior of programmers and sharing
                 related concepts among functions. We conducted two
                 experiments: first, an experiment with 49 C/C++
                 programmers to compare Portfolio to Google Code Search
                 and Koders using a standard methodology for evaluating
                 information-retrieval-based engines; and second, an
                 experiment with 19 Java programmers to compare
                 Portfolio to Koders. The results show with strong
                 statistical significance that users find more relevant
                 functions with higher precision with Portfolio than
                 with Google Code Search and Koders. We also show that
                 by using PageRank, Portfolio is able to rank returned
                 relevant functions more efficiently.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
  keywords =     "PageRank algorithm",
}

@Article{Wursch:2013:EQF,
  author =       "Michael W{\"u}rsch and Emanuel Giger and Harald C.
                 Gall",
  title =        "Evaluating a query framework for software evolution
                 data",
  journal =      j-TOSEM,
  volume =       "22",
  number =       "4",
  pages =        "38:1--38:??",
  month =        oct,
  year =         "2013",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2522920.2522931",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 30 12:18:03 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "With the steady advances in tooling to support
                 software engineering, mastering all the features of
                 modern IDEs, version control systems, and project
                 trackers is becoming increasingly difficult. Answering
                 even the most common developer questions can be
                 surprisingly tedious and difficult. In this article we
                 present a user study with 35 subjects to evaluate our
                 quasi-natural language interface that provides access
                 to various facets of the evolution of a software system
                 but requires almost zero learning effort. Our approach
                 is tightly woven into the Eclipse IDE and allows
                 developers to answer questions related to source code,
                 development history, or bug and issue management. The
                 results of our evaluation show that our query interface
                 can outperform classical software engineering tools in
                 terms of correctness, while yielding significant time
                 savings to its users and greatly advancing the state of
                 the art in terms of usability and learnability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2014:Ea,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559939",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Haesevoets:2014:ACS,
  author =       "Robrecht Haesevoets and Danny Weyns and Tom Holvoet",
  title =        "Architecture-centric support for adaptive service
                 collaborations",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "2:1--2:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559937",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In today's volatile business environments,
                 collaboration between information systems, both within
                 and across company borders, has become essential to
                 success. An efficient supply chain, for example,
                 requires the collaboration of distributed and
                 heterogeneous systems of multiple companies. Developing
                 such collaborative applications and building the
                 supporting information systems poses several
                 engineering challenges. A key challenge is to manage
                 the ever-growing design complexity. In this article, we
                 argue that software architecture should play a more
                 prominent role in the development of collaborative
                 applications. This can help to better manage design
                 complexity by modularizing collaborations and
                 separating concerns. State-of-the-art solutions,
                 however, often lack proper abstractions for modeling
                 collaborations at architectural level or do not reify
                 these abstractions at detailed design and
                 implementation level. Developers, on the other hand,
                 rely on middleware, business process management, and
                 Web services, techniques that mainly focus on low-level
                 infrastructure. To address the problem of managing the
                 design complexity of collaborative applications, we
                 present Macodo. Macodo consists of three complementary
                 parts: (1) a set of abstractions for modeling adaptive
                 collaborations, (2) a set of architectural views, the
                 main contribution of this article, that reify these
                 abstractions at architectural level, and (3) a
                 proof-of-concept middleware infrastructure that
                 supports the architectural abstractions at design and
                 implementation level. We evaluate the architectural
                 views in a controlled experiment. Results show that the
                 use of Macodo can reduce fault density and design
                 complexity, and improve reuse and productivity. The
                 main contributions of this article are illustrated in a
                 supply chain management case.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tappenden:2014:ACC,
  author =       "Andrew F. Tappenden and James Miller",
  title =        "Automated cookie collection testing",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "3:1--3:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559936",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Cookies are used by over 80\% of Web applications
                 utilizing dynamic Web application frameworks.
                 Applications deploying cookies must be rigorously
                 verified to ensure that the application is robust and
                 secure. Given the intense time-to-market pressures
                 faced by modern Web applications, testing strategies
                 that are low cost and automatable are required.
                 Automated Cookie Collection Testing (CCT) is presented,
                 and is empirically demonstrated to be a low-cost and
                 highly effective automated testing solution for modern
                 Web applications. Automatable test oracles and
                 evaluation metrics specifically designed for Web
                 applications are presented, and are shown to be
                 significant diagnostic tests. Automated CCT is shown to
                 detect faults within five real-world Web applications.
                 A case study of over 580 test results for a single
                 application is presented demonstrating that automated
                 CCT is an effective testing strategy. Moreover, CCT is
                 found to detect security bugs in a Web application
                 released into full production.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bavota:2014:ISM,
  author =       "Gabriele Bavota and Malcom Gethers and Rocco Oliveto
                 and Denys Poshyvanyk and Andrea de Lucia",
  title =        "Improving software modularization via automated
                 analysis of latent topics and dependencies",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "4:1--4:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559935",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Oftentimes, during software maintenance the original
                 program modularization decays, thus reducing its
                 quality. One of the main reasons for such architectural
                 erosion is suboptimal placement of source-code classes
                 in software packages. To alleviate this issue, we
                 propose an automated approach to help developers
                 improve the quality of software modularization. Our
                 approach analyzes underlying latent topics in source
                 code as well as structural dependencies to recommend
                 (and explain) refactoring operations aiming at moving a
                 class to a more suitable package. The topics are
                 acquired via Relational Topic Models (RTM), a
                 probabilistic topic modeling technique. The resulting
                 tool, coined as R 3 (Rational Refactoring via RTM), has
                 been evaluated in two empirical studies. The results of
                 the first study conducted on nine software systems
                 indicate that R 3 provides a coupling reduction from
                 10\% to 30\% among the software modules. The second
                 study with 62 developers confirms that R 3 is able to
                 provide meaningful recommendations (and explanations)
                 for move class refactoring. Specifically, more than
                 70\% of the recommendations were considered meaningful
                 from a functional point of view.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2014:DWN,
  author =       "Xiao Liu and Yun Yang and Dong Yuan and Jinjun Chen",
  title =        "Do we need to handle every temporal violation in
                 scientific workflow systems?",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "5:1--5:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559938",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Scientific processes are usually time constrained with
                 overall deadlines and local milestones. In scientific
                 workflow systems, due to the dynamic nature of the
                 underlying computing infrastructures such as grid and
                 cloud, execution delays often take place and result in
                 a large number of temporal violations. Since temporal
                 violation handling is expensive in terms of both
                 monetary costs and time overheads, an essential
                 question aroused is ``do we need to handle every
                 temporal violation in scientific workflow systems?''
                 The answer would be ``true'' according to existing
                 works on workflow temporal management which adopt the
                 philosophy similar to the handling of functional
                 exceptions, that is, every temporal violation should be
                 handled whenever it is detected. However, based on our
                 observation, the phenomenon of self-recovery where
                 execution delays can be automatically compensated for
                 by the saved execution time of subsequent workflow
                 activities has been entirely overlooked. Therefore,
                 considering the nonfunctional nature of temporal
                 violations, our answer is ``not necessarily true.'' To
                 take advantage of self-recovery, this article proposes
                 a novel adaptive temporal violation handling point
                 selection strategy where this phenomenon is effectively
                 utilised to avoid unnecessary temporal violation
                 handling. Based on simulations of both real-world
                 scientific workflows and randomly generated test cases,
                 the experimental results demonstrate that our strategy
                 can significantly reduce the cost on temporal violation
                 handling by over 96\% while maintaining extreme low
                 violation rate under normal circumstances.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mari:2014:MBS,
  author =       "Federico Mari and Igor Melatti and Ivano Salvo and
                 Enrico Tronci",
  title =        "Model-based synthesis of control software from
                 system-level formal specifications",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "6:1--6:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559934",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many embedded systems are indeed software-based
                 control systems, that is, control systems whose
                 controller consists of control software running on a
                 microcontroller device. This motivates investigation on
                 formal model-based design approaches for automatic
                 synthesis of embedded systems control software. We
                 present an algorithm, along with a tool QKS
                 implementing it, that from a formal model (as a
                 discrete-time linear hybrid system ) of the controlled
                 system ( plant ), implementation specifications (that
                 is, number of bits in the Analog-to-Digital, AD,
                 conversion) and system-level formal specifications
                 (that is, safety and liveness requirements for the
                 closed loop system ) returns correct-by-construction
                 control software that has a Worst-Case Execution Time
                 (WCET) linear in the number of AD bits and meets the
                 given specifications. We show feasibility of our
                 approach by presenting experimental results on using it
                 to synthesize control software for a buck DC-DC
                 converter, a widely used mixed-mode analog circuit, and
                 for the inverted pendulum.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bodden:2014:JPI,
  author =       "Eric Bodden and {\'E}ric Tanter and Milton Inostroza",
  title =        "Join point interfaces for safe and flexible decoupling
                 of aspects",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "7:1--7:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559933",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In current aspect-oriented systems, aspects usually
                 carry, through their pointcuts, explicit references to
                 the base code. Those references are fragile and hinder
                 important software engineering properties such as
                 modular reasoning and independent evolution of aspects
                 and base code. In this work, we introduce a novel
                 abstraction called Join Point Interface, which, by
                 design, aids modular reasoning and independent
                 evolution by decoupling aspects from base code and by
                 providing a modular type-checking algorithm. Join point
                 interfaces can be used both with implicit announcement
                 through pointcuts, and with explicit announcement,
                 using closure join points. Join point interfaces
                 further offer polymorphic dispatch on join points, with
                 an advice-dispatch semantics akin to multimethods. To
                 support flexible join point matching, we incorporate
                 into our language an earlier proposal for generic
                 advice, and introduce a mechanism for controlled global
                 quantification. We motivate each language feature in
                 detail, showing that it is necessary to obtain a
                 language design that is both type safe and flexible
                 enough to support typical aspect-oriented programming
                 idioms. We have implemented join point interfaces as an
                 open-source extension to AspectJ. A case study on
                 existing aspect-oriented programs supports our design,
                 and in particular shows the necessity of both generic
                 interfaces and some mechanism for global
                 quantification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Masri:2014:PCC,
  author =       "Wes Masri and Rawad Abou Assi",
  title =        "Prevalence of coincidental correctness and mitigation
                 of its impact on fault localization",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "8:1--8:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559932",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Researchers have argued that for failure to be
                 observed the following three conditions must be met: $
                 C_R $ = the defect was reached; $ C_I $ = the program
                 has transitioned into an infectious state; and $ C_P $
                 = the infection has propagated to the output.
                 Coincidental Correctness (CC) arises when the program
                 produces the correct output while condition $ C_R $ is
                 met but not $ C_P $. We recognize two forms of
                 coincidental correctness, weak and strong. In weak CC,
                 $ C_R $ is met, whereas $ C_I $ might or might not be
                 met, whereas in strong CC, both $ C_R $ and $ C_I $ are
                 met. In this work we first show that CC is prevalent in
                 both of its forms and demonstrate that it is a safety
                 reducing factor for Coverage-Based Fault Localization
                 (CBFL). We then propose two techniques for cleansing
                 test suites from coincidental correctness to enhance
                 CBFL, given that the test cases have already been
                 classified as failing or passing. We evaluated the
                 effectiveness of our techniques by empirically
                 quantifying their accuracy in identifying weak CC
                 tests. The results were promising, for example, the
                 better performing technique, using 105 test suites and
                 statement coverage, exhibited 9\% false negatives, 30\%
                 false positives, and no false negatives nor false
                 positives in 14.3\% of the test suites. Also using 73
                 test suites and more complex coverage, the numbers were
                 12\%, 19\%, and 15\%, respectively.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Briand:2014:TSD,
  author =       "Lionel Briand and Davide Falessi and Shiva Nejati and
                 Mehrdad Sabetzadeh and Tao Yue",
  title =        "Traceability and {SysML} design slices to support
                 safety inspections: a controlled experiment",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "9:1--9:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2559978",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Certifying safety-critical software and ensuring its
                 safety requires checking the conformance between safety
                 requirements and design. Increasingly, the development
                 of safety-critical software relies on modeling, and the
                 System Modeling Language (SysML) is now commonly used
                 in many industry sectors. Inspecting safety conformance
                 by comparing design models against safety requirements
                 requires safety inspectors to browse through large
                 models and is consequently time consuming and
                 error-prone. To address this, we have devised a
                 mechanism to establish traceability between
                 (functional) safety requirements and SysML design
                 models to extract design slices (model fragments) that
                 filter out irrelevant details but keep enough context
                 information for the slices to be easy to inspect and
                 understand. In this article, we report on a controlled
                 experiment assessing the impact of the traceability and
                 slicing mechanism on inspectors' conformance decisions
                 and effort. Results show a significant decrease in
                 effort and an increase in decisions' correctness and
                 level of certainty.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2014:DSP,
  author =       "Yuming Zhou and Baowen Xu and Hareton Leung and Lin
                 Chen",
  title =        "An in-depth study of the potentially confounding
                 effect of class size in fault prediction",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "1",
  pages =        "10:1--10:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2556777",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sat Feb 15 11:14:44 MST 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Background. The extent of the potentially confounding
                 effect of class size in the fault prediction context is
                 not clear, nor is the method to remove the potentially
                 confounding effect, or the influence of this removal on
                 the performance of fault-proneness prediction models.
                 Objective. We aim to provide an in-depth understanding
                 of the effect of class size on the true associations
                 between object-oriented metrics and fault-proneness.
                 Method. We first employ statistical methods to examine
                 the extent of the potentially confounding effect of
                 class size in the fault prediction context. After that,
                 we propose a linear regression-based method to remove
                 the potentially confounding effect. Finally, we
                 empirically investigate whether this removal could
                 improve the prediction performance of fault-proneness
                 prediction models. Results. Based on open-source
                 software systems, we found: (a) the confounding effect
                 of class size on the associations between
                 object-oriented metrics and fault-proneness in general
                 exists; (b) the proposed linear regression-based method
                 can effectively remove the confounding effect; and (c)
                 after removing the confounding effect, the prediction
                 performance of fault prediction models with respect to
                 both ranking and classification can in general be
                 significantly improved. Conclusion. We should remove
                 the confounding effect of class size when building
                 fault prediction models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2014:Eb,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "11:1--11:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2581373",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pan:2014:GTG,
  author =       "Kai Pan and Xintao Wu and Tao Xie",
  title =        "Guided test generation for database applications via
                 synthesized database interactions",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "12:1--12:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491529",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Testing database applications typically requires the
                 generation of tests consisting of both program inputs
                 and database states. Recently, a testing technique
                 called Dynamic Symbolic Execution (DSE) has been
                 proposed to reduce manual effort in test generation for
                 software applications. However, applying DSE to
                 generate tests for database applications faces various
                 technical challenges. For example, the database
                 application under test needs to physically connect to
                 the associated database, which may not be available for
                 various reasons. The program inputs whose values are
                 used to form the executed queries are not treated
                 symbolically, posing difficulties for generating valid
                 database states or appropriate database states for
                 achieving high coverage of query-result-manipulation
                 code. To address these challenges, in this article, we
                 propose an approach called SynDB that synthesizes new
                 database interactions to replace the original ones from
                 the database application under test. In this way, we
                 bridge various constraints within a database
                 application: query-construction constraints, query
                 constraints, database schema constraints, and
                 query-result-manipulation constraints. We then apply a
                 state-of-the-art DSE engine called Pex for .NET from
                 Microsoft Research to generate both program inputs and
                 database states. The evaluation results show that tests
                 generated by our approach can achieve higher code
                 coverage than existing test generation approaches for
                 database applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Scanniello:2014:IUA,
  author =       "Giuseppe Scanniello and Carmine Gravino and Marcela
                 Genero and Jose' A. Cruz-Lemus and Genoveffa Tortora",
  title =        "On the impact of {UML} analysis models on source-code
                 comprehensibility and modifiability",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "13:1--13:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2491912",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We carried out a family of experiments to investigate
                 whether the use of UML models produced in the
                 requirements analysis process helps in the
                 comprehensibility and modifiability of source code. The
                 family consists of a controlled experiment and 3
                 external replications carried out with students and
                 professionals from Italy and Spain. 86 participants
                 with different abilities and levels of experience with
                 UML took part. The results of the experiments were
                 integrated through the use of meta-analysis. The
                 results of both the individual experiments and
                 meta-analysis indicate that UML models produced in the
                 requirements analysis process influence neither the
                 comprehensibility of source code nor its
                 modifiability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fritz:2014:DKM,
  author =       "Thomas Fritz and Gail C. Murphy and Emerson
                 Murphy-Hill and Jingwen Ou and Emily Hill",
  title =        "Degree-of-knowledge: Modeling a developer's knowledge
                 of code",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "14:1--14:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2512207",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "As a software system evolves, the system's codebase
                 constantly changes, making it difficult for developers
                 to answer such questions as who is knowledgeable about
                 particular parts of the code or who needs to know about
                 changes made. In this article, we show that an
                 externalized model of a developer's individual
                 knowledge of code can make it easier for developers to
                 answer such questions. We introduce a
                 degree-of-knowledge model that computes automatically,
                 for each source-code element in a codebase, a real
                 value that represents a developer's knowledge of that
                 element based on a developer's authorship and
                 interaction data. We present evidence that shows that
                 both authorship and interaction data of the code are
                 important in characterizing a developer's knowledge of
                 code. We report on the usage of our model in case
                 studies on expert finding, knowledge transfer, and
                 identifying changes of interest. We show that our model
                 improves upon an existing expertise-finding approach
                 and can accurately identify changes for which a
                 developer should likely be aware. We discuss how our
                 model may provide a starting point for knowledge
                 transfer but that more refinement is needed. Finally,
                 we discuss the robustness of the model across multiple
                 development sites.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lu:2014:RBS,
  author =       "Lunjin Lu and Dae-Kyoo Kim",
  title =        "Required behavior of sequence diagrams: Semantics and
                 conformance",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "15:1--15:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2523108",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many reusable software artifacts such as design
                 patterns and design aspects make use of UML sequence
                 diagrams to describe interaction behaviors. When a
                 pattern or an aspect is reused in an application, it is
                 important to ensure that the sequence diagrams for the
                 application conform to the corresponding sequence
                 diagrams for the pattern or aspect. Reasoning about
                 conformance relationship between sequence diagrams has
                 not been addressed adequately in literature. In this
                 article, we focus on required behaviors specified by a
                 UML sequence diagram and provide a semantic-based
                 formalization of conformance relationships between
                 sequence diagrams. A novel trace semantics is first
                 given that captures precisely required behaviors. A
                 refinement relation between sequence diagrams is then
                 defined based on the semantics. The refinement relation
                 allows a sequence diagram to be refined by changing its
                 structure so long as its required behaviors are
                 preserved. A conformance relation between sequence
                 diagrams is finally given that includes the refinement
                 relation as a special case. It allows one to introduce
                 and rename lifelines, messages, and system variables
                 when reusing sequence diagrams. Properties of the
                 semantics, refinement, and conformance relations are
                 studied. Two case studies are provided to illustrate
                 the efficacy of semantic-based conformance reasoning.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Unterkalmsteiner:2014:TRE,
  author =       "M. Unterkalmsteiner and R. Feldt and T. Gorschek",
  title =        "A taxonomy for requirements engineering and software
                 test alignment",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "16:1--16:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2523088",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Requirements Engineering and Software Testing are
                 mature areas and have seen a lot of research.
                 Nevertheless, their interactions have been sparsely
                 explored beyond the concept of traceability. To fill
                 this gap, we propose a definition of requirements
                 engineering and software test (REST) alignment, a
                 taxonomy that characterizes the methods linking the
                 respective areas, and a process to assess alignment.
                 The taxonomy can support researchers to identify new
                 opportunities for investigation, as well as
                 practitioners to compare alignment methods and evaluate
                 alignment, or lack thereof. We constructed the REST
                 taxonomy by analyzing alignment methods published in
                 literature, iteratively validating the emerging
                 dimensions. The resulting concept of an information
                 dyad characterizes the exchange of information required
                 for any alignment to take place. We demonstrate use of
                 the taxonomy by applying it on five in-depth cases and
                 illustrate angles of analysis on a set of thirteen
                 alignment methods. In addition, we developed an
                 assessment framework (REST-bench), applied it in an
                 industrial assessment, and showed that it, with a low
                 effort, can identify opportunities to improve REST
                 alignment. Although we expect that the taxonomy can be
                 further refined, we believe that the information dyad
                 is a valid and useful construct to understand
                 alignment.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ganesan:2014:AED,
  author =       "Dharmalingam Ganesan and Mikael Lindvall",
  title =        "{ADAM}: External dependency-driven architecture
                 discovery and analysis of quality attributes",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "17:1--17:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2529998",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article introduces the Architecture Discovery and
                 Analysis Method (ADAM). ADAM supports the discovery of
                 module and runtime views as well as the analysis of
                 quality attributes, such as testability, performance,
                 and maintainability, of software systems. The premise
                 of ADAM is that the implementation constructs,
                 architecture constructs, concerns, and quality
                 attributes are all influenced by the external entities
                 (e.g., libraries, frameworks, COTS software) used by
                 the system under analysis. The analysis uses such
                 external dependencies to identify, classify, and review
                 a minimal set of key source-code files supported by a
                 knowledge base of the external entities. Given the
                 benefits of analyzing external dependencies as a way to
                 discover architectures and potential risks, it is
                 demonstrated that dependencies to external entities are
                 useful not only for architecture discovery but also for
                 analysis of quality attributes. ADAM is evaluated using
                 the NASA's Space Network Access System (SNAS). The
                 results show that this method offers systematic
                 guidelines for discovering the architecture and
                 locating potential risks (e.g., low testability and
                 decreased performance) that are hidden deep inside the
                 system implementation. Some generally applicable
                 lessons for developers and analysts, as well as threats
                 to validity are also discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Stol:2014:KFA,
  author =       "Klaas-Jan Stol and Paris Avgeriou and Muhammad Ali
                 Babar and Yan Lucas and Brian Fitzgerald",
  title =        "Key factors for adopting inner source",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "18:1--18:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2533685",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A number of organizations have adopted Open Source
                 Software (OSS) development practices to support or
                 augment their software development processes, a
                 phenomenon frequently referred to as Inner Source.
                 However the adoption of Inner Source is not a
                 straightforward issue. Many organizations are
                 struggling with the question of whether Inner Source is
                 an appropriate approach to software development for
                 them in the first place. This article presents a
                 framework derived from the literature on Inner Source,
                 which identifies nine important factors that need to be
                 considered when implementing Inner Source. The
                 framework can be used as a probing instrument to assess
                 an organization on these nine factors so as to gain an
                 understanding of whether or not Inner Source is
                 suitable. We applied the framework in three case
                 studies at Philips Healthcare, Neopost Technologies,
                 and Rolls-Royce, which are all large organizations that
                 have either adopted Inner Source or were planning to do
                 so. Based on the results presented in this article, we
                 outline directions for future research.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Harman:2014:ESS,
  author =       "Mark Harman and Jens Krinke and Inmaculada Medina-Bulo
                 and Francisco Palomo-Lozano and Jian Ren and Shin Yoo",
  title =        "Exact scalable sensitivity analysis for the next
                 release problem",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "19:1--19:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2537853",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The nature of the requirements analysis problem, based
                 as it is on uncertain and often inaccurate estimates of
                 costs and effort, makes sensitivity analysis important.
                 Sensitivity analysis allows the decision maker to
                 identify those requirements and budgets that are
                 particularly sensitive to misestimation. However,
                 finding scalable sensitivity analysis techniques is not
                 easy because the underlying optimization problem is
                 NP-hard. This article introduces an approach to
                 sensitivity analysis based on exact optimization. We
                 implemented this approach as a tool, O ATSAC, which
                 allowed us to experimentally evaluate the scalability
                 and applicability of Requirements Sensitivity Analysis
                 (RSA). Our results show that OATSAC scales sufficiently
                 well for practical applications in Requirements
                 Sensitivity Analysis. We also show how the sensitivity
                 analysis can yield insights into difficult and
                 otherwise obscure interactions between budgets,
                 requirements costs, and estimate inaccuracies using a
                 real-world case study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Moscato:2014:DTV,
  author =       "Mariano M. Moscato and Carlos G. Lopez Pombo and
                 Marcelo F. Frias",
  title =        "{Dynamite}: a tool for the verification of alloy
                 models based on {PVS}",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "2",
  pages =        "20:1--20:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2544136",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 2 16:21:37 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Automatic analysis of Alloy models is supported by the
                 Alloy Analyzer, a tool that translates an Alloy model
                 to a propositional formula that is then analyzed using
                 off-the-shelf SAT solvers. The translation requires
                 user-provided bounds on the sizes of data domains. The
                 analysis is limited by the bounds and is therefore
                 partial. Thus, the Alloy Analyzer may not be
                 appropriate for the analysis of critical applications
                 where more conclusive results are necessary. Dynamite
                 is an extension of PVS that embeds a complete calculus
                 for Alloy. It also includes extensions to PVS that
                 allow one to improve the proof effort by, for instance,
                 automatically analyzing new hypotheses with the aid of
                 the Alloy Analyzer. Since PVS sequents may get
                 cluttered with unnecessary formulas, we use the Alloy
                 unsat-core extraction feature in order to refine proof
                 sequents. An internalization of Alloy's syntax as an
                 Alloy specification allows us to use the Alloy Analyzer
                 for producing witnesses for proving existentially
                 quantified formulas. Dynamite complements the partial
                 automatic analysis offered by the Alloy Analyzer with
                 semi-automatic verification through theorem proving. It
                 also improves the theorem proving experience by using
                 the Alloy Analyzer for early error detection, sequent
                 refinement, and witness generation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Islam:2014:GTC,
  author =       "Mainul Islam and Christoph Csallner",
  title =        "Generating Test Cases for Programs that Are Coded
                 against Interfaces and Annotations",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "21:1--21:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2544135",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Automatic test case generation for software programs
                 is very powerful but suffers from a key limitation.
                 That is, most current test case generation techniques
                 fail to cover testee code when covering that code
                 requires additional pieces of code not yet part of the
                 program under test. To address some of these cases, the
                 Pex state-of-the-art test case generator can generate
                 basic mock code. However, current test case generators
                 cannot handle cases in which the code under test uses
                 multiple interfaces, annotations, or reflection. To
                 cover such code in an object-oriented setting, we
                 describe a novel technique for generating test cases
                 and mock classes. The technique consists of collecting
                 constraints on interfaces, annotations, and reflection,
                 combining them with program constraints collected
                 during dynamic symbolic execution, encoding them in a
                 constraint system, solving them with an off-the-shelf
                 constraint solver, and mapping constraint solutions to
                 test cases and custom mock classes. We demonstrate the
                 value of this technique on open-source applications.
                 Our approach covered such third-party code with
                 generated mock classes, while competing approaches
                 failed to cover the code and sometimes produced
                 unintended side-effects such as filling the screen with
                 dialog boxes and writing into the file system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Layman:2014:MER,
  author =       "Lucas Layman and Victor R. Basili and Marvin V.
                 Zelkowitz",
  title =        "A Methodology for Exposing Risk in Achieving Emergent
                 System Properties",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "22:1--22:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2560048",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Determining whether systems achieve desired emergent
                 properties, such as safety or reliability, requires an
                 analysis of the system as a whole, often in later
                 development stages when changes are difficult and
                 costly to implement. In this article we propose the
                 Process Risk Indicator (PRI) methodology for analyzing
                 and evaluating emergent properties early in the
                 development cycle. A fundamental assumption of system
                 engineering is that risk mitigation processes reduce
                 system risks, yet these processes may also be a source
                 of risk: (1) processes may not be appropriate for
                 achieving the desired emergent property; or (2)
                 processes may not be followed appropriately. PRI
                 analyzes development process artifacts (e.g., designs
                 pertaining to reliability or safety analysis reports)
                 to quantify process risks that may lead to higher
                 system risk. We applied PRI to the hazard analysis
                 processes of a network-centric, Department of Defense
                 system-of-systems and two NASA spaceflight projects to
                 assess the risk of not achieving one such emergent
                 property, software safety, during the early stages of
                 the development lifecycle. The PRI methodology was used
                 to create measurement baselines for process indicators
                 of software safety risk, to identify risks in the
                 hazard analysis process, and to provide feedback to
                 projects for reducing these risks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2014:SRB,
  author =       "Guoqing Xu and Nick Mitchell and Matthew Arnold and
                 Atanas Rountev and Edith Schonberg and Gary Sevitsky",
  title =        "Scalable Runtime Bloat Detection Using Abstract
                 Dynamic Slicing",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "23:1--23:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2560047",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many large-scale Java applications suffer from runtime
                 bloat. They execute large volumes of methods and create
                 many temporary objects, all to execute relatively
                 simple operations. There are large opportunities for
                 performance optimizations in these applications, but
                 most are being missed by existing optimization and
                 tooling technology. While JIT optimizations struggle
                 for a few percent improvement, performance experts
                 analyze deployed applications and regularly find gains
                 of 2$ \times $ or more. Finding such big gains is
                 difficult, for both humans and compilers, because of
                 the diffuse nature of runtime bloat. Time is spread
                 thinly across calling contexts, making it difficult to
                 judge how to improve performance. Our experience shows
                 that, in order to identify large performance
                 bottlenecks in a program, it is more important to
                 understand its dynamic dataflow than traditional
                 performance metrics, such as running time. This article
                 presents a general framework for designing and
                 implementing scalable analysis algorithms to find
                 causes of bloat in Java programs. At the heart of this
                 framework is a generalized form of runtime dependence
                 graph computed by abstract dynamic slicing, a
                 semantics-aware technique that achieves high
                 scalability by performing dynamic slicing over bounded
                 abstract domains. The framework is instantiated to
                 create two independent dynamic analyses, copy profiling
                 and cost-benefit analysis, that help programmers
                 identify performance bottlenecks by identifying,
                 respectively, high-volume copy activities and data
                 structures that have high construction cost but low
                 benefit for the forward execution. We have successfully
                 applied these analyses to large-scale and long-running
                 Java applications. We show that both analyses are
                 effective at detecting inefficient operations that can
                 be optimized for better performance. We also
                 demonstrate that the general framework is flexible
                 enough to be instantiated for dynamic analyses in a
                 variety of application domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{deFrancesco:2014:GTE,
  author =       "Nicoletta de Francesco and Giuseppe Lettieri and
                 Antonella Santone and Gigliola Vaglini",
  title =        "{GreASE}: a Tool for Efficient {``Nonequivalence''}
                 Checking",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "24:1--24:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2560563",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Equivalence checking plays a crucial role in formal
                 verification to ensure the correctness of concurrent
                 systems. However, this method cannot be scaled as
                 easily with the increasing complexity of systems due to
                 the state explosion problem. This article presents an
                 efficient procedure, based on heuristic search, for
                 checking Milner's strong and weak equivalence; to
                 achieve higher efficiency, we actually search for a
                 difference between two processes to be discovered as
                 soon as possible, thus the heuristics aims to find a
                 counterexample, even if not the minimum one, to prove
                 nonequivalence. The presented algorithm builds the
                 system state graph on-the-fly, during the checking, and
                 the heuristics promotes the construction of the more
                 promising subgraph. The heuristic function is syntax
                 based, but the approach can be applied to different
                 specification languages such as CCS, LOTOS, and CSP,
                 provided that the language semantics is based on the
                 concept of transition. The algorithm to explore the
                 search space of the problem is based on a greedy
                 technique; GreASE (Greedy Algorithm for System
                 Equivalence), the tool supporting the approach, is used
                 to evaluate the achieved reduction of both state-space
                 size and time with respect to other verification
                 environments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Behjati:2014:ALC,
  author =       "Razieh Behjati and Shiva Nejati and Lionel C. Briand",
  title =        "Architecture-Level Configuration of Large-Scale
                 Embedded Software Systems",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "25:1--25:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2581376",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Configuration in the domain of Integrated Control
                 Systems (ICS) is largely manual, laborious, and error
                 prone. In this article, we propose a model-based
                 configuration approach that provides automation support
                 for reducing configuration effort and the likelihood of
                 configuration errors in the ICS domain. We ground our
                 approach on component-based specifications of ICS
                 families. We then develop a configuration algorithm
                 using constraint satisfaction techniques over finite
                 domains to generate products that are consistent with
                 respect to their ICS family specifications. We reason
                 about the termination and consistency of our
                 configuration algorithm analytically. We evaluate the
                 effectiveness of our configuration approach by applying
                 it to a real subsea oil production system.
                 Specifically, we have rebuilt a number of existing
                 verified product configurations of our industry
                 partner. Our experience shows that our approach can
                 automatically infer up to 50\% of the configuration
                 decisions, and reduces the complexity of making
                 configuration decisions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Stolee:2014:SSS,
  author =       "Kathryn T. Stolee and Sebastian Elbaum and Daniel
                 Dobos",
  title =        "Solving the Search for Source Code",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "3",
  pages =        "26:1--26:??",
  month =        may,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2581377",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:52 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Programmers frequently search for source code to reuse
                 using keyword searches. The search effectiveness in
                 facilitating reuse, however, depends on the
                 programmer's ability to specify a query that captures
                 how the desired code may have been implemented.
                 Further, the results often include many irrelevant
                 matches that must be filtered manually. More semantic
                 search approaches could address these limitations, yet
                 existing approaches are either not flexible enough to
                 find approximate matches or require the programmer to
                 define complex specifications as queries. We propose a
                 novel approach to semantic code search that addresses
                 several of these limitations and is designed for
                 queries that can be described using a concrete
                 input/output example. In this approach, programmers
                 write lightweight specifications as inputs and expected
                 output examples. Unlike existing approaches to semantic
                 search, we use an SMT solver to identify programs or
                 program fragments in a repository, which have been
                 automatically transformed into constraints using
                 symbolic analysis, that match the programmer-provided
                 specification. We instantiated and evaluated this
                 approach in subsets of three languages, the Java String
                 library, Yahoo! Pipes mashup language, and SQL select
                 statements, exploring its generality, utility, and
                 trade-offs. The results indicate that this approach is
                 effective at finding relevant code, can be used on its
                 own or to filter results from keyword searches to
                 increase search precision, and is adaptable to find
                 approximate matches and then guide modifications to
                 match the user specifications when exact matches do not
                 already exist. These gains in precision and flexibility
                 come at the cost of performance, for which underlying
                 factors and mitigation strategies are identified.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2014:E,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "27:1--27:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2656368",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Murphy:2014:ISI,
  author =       "Gail C. Murphy and Mauro Pezz{\'e}",
  title =        "Introduction to the Special Issue {International
                 Conference on Software Engineering (ICSE 2012)}",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "28:1--28:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2658849",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Moller:2014:ADC,
  author =       "Anders M{\o}ller and Mathias Schwarz",
  title =        "Automated Detection of Client-State Manipulation
                 Vulnerabilities",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "29:1--29:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2531921",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Web application programmers must be aware of a wide
                 range of potential security risks. Although the most
                 common pitfalls are well described and categorized in
                 the literature, it remains a challenging task to ensure
                 that all guidelines are followed. For this reason, it
                 is desirable to construct automated tools that can
                 assist the programmers in the application development
                 process by detecting weaknesses. Many vulnerabilities
                 are related to Web application code that stores
                 references to application state in the generated HTML
                 documents to work around the statelessness of the HTTP
                 protocol. In this article, we show that such
                 client-state manipulation vulnerabilities are amenable
                 to tool-supported detection. We present a static
                 analysis for the widely used frameworks Java Servlets,
                 JSP, and Struts. Given a Web application archive as
                 input, the analysis identifies occurrences of client
                 state and infers the information flow between the
                 client state and the shared application state on the
                 server. This makes it possible to check how
                 client-state manipulation performed by malicious users
                 may affect the shared application state and cause
                 leakage or modifications of sensitive information. The
                 warnings produced by the tool help the application
                 programmer identify vulnerabilities before deployment.
                 The inferred information can also be applied to
                 configure a security filter that automatically guards
                 against attacks at runtime. Experiments on a collection
                 of open-source Web applications indicate that the
                 static analysis is able to effectively help the
                 programmer prevent client-state manipulation
                 vulnerabilities. The analysis detects a total of 4,802
                 client-state parameters in ten applications, whereof
                 4,437 are classified as safe and 241 reveal exploitable
                 vulnerabilities.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nguyen:2014:DDI,
  author =       "Thanhvu Nguyen and Deepak Kapur and Westley Weimer and
                 Stephanie Forrest",
  title =        "{DIG}: a Dynamic Invariant Generator for Polynomial
                 and Array Invariants",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "30:1--30:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2556782",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article describes and evaluates DIG, a dynamic
                 invariant generator that infers invariants from
                 observed program traces, focusing on numerical and
                 array variables. For numerical invariants, DIG supports
                 both nonlinear equalities and inequalities of arbitrary
                 degree defined over numerical program variables. For
                 array invariants, DIG generates nested relations among
                 multidimensional array variables. These properties are
                 nontrivial and challenging for current static and
                 dynamic invariant analysis methods. The key difference
                 between DIG and existing dynamic methods is its
                 generative technique, which infers invariants directly
                 from traces, instead of using traces to filter out
                 predefined templates. To generate accurate invariants,
                 DIG employs ideas and tools from the mathematical and
                 formal methods domains, including equation solving,
                 polyhedra construction, and theorem proving; for
                 example, DIG represents and reasons about polynomial
                 invariants using geometric shapes. Experimental results
                 on 27 mathematical algorithms and an implementation of
                 AES encryption provide evidence that DIG is effective
                 at generating invariants for these programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Maalej:2014:CPC,
  author =       "Walid Maalej and Rebecca Tiarks and Tobias Roehm and
                 Rainer Koschke",
  title =        "On the Comprehension of Program Comprehension",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "31:1--31:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2622669",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Research in program comprehension has evolved
                 considerably over the past decades. However, only
                 little is known about how developers practice program
                 comprehension in their daily work. This article reports
                 on qualitative and quantitative research to comprehend
                 the strategies, tools, and knowledge used for program
                 comprehension. We observed 28 professional developers,
                 focusing on their comprehension behavior, strategies
                 followed, and tools used. In an online survey with
                 1,477 respondents, we analyzed the importance of
                 certain types of knowledge for comprehension and where
                 developers typically access and share this knowledge.
                 We found that developers follow pragmatic comprehension
                 strategies depending on context. They try to avoid
                 comprehension whenever possible and often put
                 themselves in the role of users by inspecting graphical
                 interfaces. Participants confirmed that standards,
                 experience, and personal communication facilitate
                 comprehension. The team size, its distribution, and
                 open-source experience influence their knowledge
                 sharing and access behavior. While face-to-face
                 communication is preferred for accessing knowledge,
                 knowledge is frequently shared in informal comments.
                 Our results reveal a gap between research and practice,
                 as we did not observe any use of comprehension tools
                 and developers seem to be unaware of them. Overall, our
                 findings call for reconsidering the research agendas
                 towards context-aware tool support.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2014:ATV,
  author =       "Pingyu Zhang and Sebastian Elbaum",
  title =        "Amplifying Tests to Validate Exception Handling Code:
                 an Extended Study in the Mobile Application Domain",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "32:1--32:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2652483",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Validating code handling exceptional behavior is
                 difficult, particularly when dealing with external
                 resources that may be noisy and unreliable, as it
                 requires (1) systematic exploration of the space of
                 exceptions that may be thrown by the external
                 resources, and (2) setup of the context to trigger
                 specific patterns of exceptions. In this work, we first
                 present a study quantifying the magnitude of the
                 problem by inspecting the bug repositories of a set of
                 popular applications in the increasingly relevant
                 domain of Android mobile applications. The study
                 revealed that 22\% of the confirmed and fixed bugs have
                 to do with poor exceptional handling code, and half of
                 those correspond to interactions with external
                 resources. We then present an approach that addresses
                 this challenge by performing an systematic
                 amplification of the program space explored by a test
                 by manipulating the behavior of external resources.
                 Each amplification attempts to expose a program's
                 exception handling constructs to new behavior by
                 mocking an external resource so that it returns
                 normally or throws an exception following a predefined
                 set of patterns. Our assessment of the approach
                 indicates that it can be fully automated, is powerful
                 enough to detect 67\% of the faults reported in the bug
                 reports of this kind, and is precise enough that 78\%
                 of the detected anomalies are fixed, and it has a great
                 potential to assist developers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hall:2014:SCS,
  author =       "Tracy Hall and Min Zhang and David Bowes and Yi Sun",
  title =        "Some Code Smells Have a Significant but Small Effect
                 on Faults",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "33:1--33:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2629648",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We investigate the relationship between faults and
                 five of Fowler et al.'s least-studied smells in code:
                 Data Clumps, Switch Statements, Speculative Generality,
                 Message Chains, and Middle Man. We developed a tool to
                 detect these five smells in three open-source systems:
                 Eclipse, ArgoUML, and Apache Commons. We collected
                 fault data from the change and fault repositories of
                 each system. We built Negative Binomial regression
                 models to analyse the relationships between smells and
                 faults and report the McFadden effect size of those
                 relationships. Our results suggest that Switch
                 Statements had no effect on faults in any of the three
                 systems; Message Chains increased faults in two
                 systems; Message Chains which occurred in larger files
                 reduced faults; Data Clumps reduced faults in Apache
                 and Eclipse but increased faults in ArgoUML; Middle Man
                 reduced faults only in ArgoUML, and Speculative
                 Generality reduced faults only in Eclipse. File size
                 alone affects faults in some systems but not in all
                 systems. Where smells did significantly affect faults,
                 the size of that effect was small (always under 10
                 percent). Our findings suggest that some smells do
                 indicate fault-prone code in some circumstances but
                 that the effect that these smells have on faults is
                 small. Our findings also show that smells have
                 different effects on different systems. We conclude
                 that arbitrary refactoring is unlikely to significantly
                 reduce fault-proneness and in some cases may increase
                 fault-proneness.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2014:SSA,
  author =       "Yueqi Li and S. C. Cheung and Xiangyu Zhang and Yepang
                 Liu",
  title =        "Scaling Up Symbolic Analysis by Removing
                 $z$-Equivalent States",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "34:1--34:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2652484",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Path explosion is a major issue in applying
                 path-sensitive symbolic analysis to large programs. We
                 observe that many symbolic states generated by the
                 symbolic analysis of a procedure are indistinguishable
                 to its callers. It is, therefore, possible to keep only
                 one state from each set of equivalent symbolic states
                 without affecting the analysis result. Based on this
                 observation, we propose an equivalence relation called
                 z-equivalence, which is weaker than logical
                 equivalence, to relate a large number of z-equivalent
                 states. We prove that z-equivalence is strong enough to
                 guarantee that paths to be traversed by the symbolic
                 analysis of two z-equivalent states are identical,
                 giving the same solutions to satisfiability and
                 validity queries. We propose a sound linear algorithm
                 to detect z-equivalence. Our experiments show that the
                 symbolic analysis that leverages z-equivalence is able
                 to achieve more than ten orders of magnitude reduction
                 in terms of search space. The reduction significantly
                 alleviates the path explosion problem, enabling us to
                 apply symbolic analysis in large programs such as
                 Hadoop and Linux Kernel.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rigby:2014:PRO,
  author =       "Peter C. Rigby and Daniel M. German and Laura Cowen
                 and Margaret-Anne Storey",
  title =        "Peer Review on Open-Source Software Projects:
                 Parameters, Statistical Models, and Theory",
  journal =      j-TOSEM,
  volume =       "23",
  number =       "4",
  pages =        "35:1--35:??",
  month =        aug,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2594458",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:54 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Peer review is seen as an important quality-assurance
                 mechanism in both industrial development and the
                 open-source software (OSS) community. The techniques
                 for performing inspections have been well studied in
                 industry; in OSS development, software peer reviews are
                 not as well understood. To develop an empirical
                 understanding of OSS peer review, we examine the review
                 policies of 25 OSS projects and study the archival
                 records of six large, mature, successful OSS projects.
                 We extract a series of measures based on those used in
                 traditional inspection experiments. We measure the
                 frequency of review, the size of the contribution under
                 review, the level of participation during review, the
                 experience and expertise of the individuals involved in
                 the review, the review interval, and the number of
                 issues discussed during review. We create statistical
                 models of the review efficiency, review interval, and
                 effectiveness, the issues discussed during review, to
                 determine which measures have the largest impact on
                 review efficacy. We find that OSS peer reviews are
                 conducted asynchronously by empowered experts who focus
                 on changes that are in their area of expertise.
                 Reviewers provide timely, regular feedback on small
                 changes. The descriptive statistics clearly show that
                 OSS review is drastically different from traditional
                 inspection.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ricca:2014:AES,
  author =       "Filippo Ricca and Giuseppe Scanniello and Marco
                 Torchiano and Gianna Reggio and Egidio Astesiano",
  title =        "Assessing the Effect of Screen Mockups on the
                 Comprehension of Functional Requirements",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "1:1--1:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2629457",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:56 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Over the last few years, the software engineering
                 community has proposed a number of modeling methods to
                 represent functional requirements. Among them, use
                 cases are recognized as an easy to use and intuitive
                 way to capture and define such requirements. Screen
                 mockups (also called user-interface sketches or user
                 interface-mockups) have been proposed as a complement
                 to use cases for improving the comprehension of
                 functional requirements. In this article, we aim at
                 quantifying the benefits achievable by augmenting use
                 cases with screen mockups in the comprehension of
                 functional requirements with respect to effectiveness,
                 effort, and efficiency. For this purpose, we conducted
                 a family of four controlled experiments, involving 139
                 participants having different profiles. The experiments
                 involved comprehension tasks performed on the
                 requirements documents of two desktop applications.
                 Independently from the participants' profile, we found
                 a statistically significant large effect of the
                 presence of screen mockups on both comprehension
                 effectiveness and comprehension task efficiency. No
                 significant effect was observed on the effort to
                 complete tasks. The main pragmatic lesson is that the
                 screen mockups addition to use cases is able to almost
                 double the efficiency of comprehension tasks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Banach:2014:CAM,
  author =       "Richard Banach and Huibiao Zhu and Wen Su and Xiaofeng
                 Wu",
  title =        "A Continuous {ASM} Modelling Approach to Pacemaker
                 Sensing",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "2:1--2:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2610375",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:56 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The cardiac pacemaker system, proposed as a problem
                 topic in the Verification Grand Challenge, offers a
                 range of difficulties to address for formal
                 specification, development, and verification
                 technologies. We focus on the sensing problem, the
                 question of whether the heart has produced a
                 spontaneous heartbeat or not. This question is plagued
                 by uncertainties arising from the often unpredictable
                 environment that a real pacemaker finds itself in. We
                 develop a time domain tracking approach to this
                 problem, as a complement to the usual frequency domain
                 approach most frequently used. We develop our case
                 study in the continuous ASM (Abstract State Machine)
                 formalism, which is briefly summarised, through a
                 series of refinement and retrenchment steps, each
                 adding new levels of complexity to the model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2014:DIS,
  author =       "Guowei Yang and Suzette Person and Neha Rungta and
                 Sarfraz Khurshid",
  title =        "Directed Incremental Symbolic Execution",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "3:1--3:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2629536",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:56 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The last few years have seen a resurgence of interest
                 in the use of symbolic execution-a program analysis
                 technique developed more than three decades ago to
                 analyze program execution paths. Scaling symbolic
                 execution to real systems remains challenging despite
                 recent algorithmic and technological advances. An
                 effective approach to address scalability is to reduce
                 the scope of the analysis. For example, in regression
                 analysis, differences between two related program
                 versions are used to guide the analysis. While such an
                 approach is intuitive, finding efficient and precise
                 ways to identify program differences, and characterize
                 their impact on how the program executes has proved
                 challenging in practice. In this article, we present
                 Directed Incremental Symbolic Execution (DiSE), a novel
                 technique for detecting and characterizing the impact
                 of program changes to scale symbolic execution. The
                 novelty of DiSE is to combine the efficiencies of
                 static analysis techniques to compute program
                 difference information with the precision of symbolic
                 execution to explore program execution paths and
                 generate path conditions affected by the differences.
                 DiSE complements other reduction and bounding
                 techniques for improving symbolic execution.
                 Furthermore, DiSE does not require analysis results to
                 be carried forward as the software evolves-only the
                 source code for two related program versions is
                 required. An experimental evaluation using our
                 implementation of DiSE illustrates its effectiveness at
                 detecting and characterizing the effects of program
                 changes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Santhiar:2014:MUT,
  author =       "Anirudh Santhiar and Omesh Pandita and Aditya Kanade",
  title =        "Mining Unit Tests for Discovery and Migration of Math
                 {APIs}",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "4:1--4:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2629506",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:56 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Today's programming languages are supported by
                 powerful third-party APIs. For a given application
                 domain, it is common to have many competing APIs that
                 provide similar functionality. Programmer productivity
                 therefore depends heavily on the programmer's ability
                 to discover suitable APIs both during an initial coding
                 phase, as well as during software maintenance. The aim
                 of this work is to support the discovery and migration
                 of math APIs. Math APIs are at the heart of many
                 application domains ranging from machine learning to
                 scientific computations. Our approach, called
                 MathFinder, combines executable specifications of
                 mathematical computations with unit tests (operational
                 specifications) of API methods. Given a math
                 expression, MathFinder synthesizes pseudo-code
                 comprised of API methods to compute the expression by
                 mining unit tests of the API methods. We present a
                 sequential version of our unit test mining algorithm
                 and also design a more scalable data-parallel version.
                 We perform extensive evaluation of MathFinder (1) for
                 API discovery, where math algorithms are to be
                 implemented from scratch and (2) for API migration,
                 where client programs utilizing a math API are to be
                 migrated to another API. We evaluated the precision and
                 recall of MathFinder on a diverse collection of math
                 expressions, culled from algorithms used in a wide
                 range of application areas such as control systems and
                 structural dynamics. In a user study to evaluate the
                 productivity gains obtained by using MathFinder for API
                 discovery, the programmers who used MathFinder finished
                 their programming tasks twice as fast as their
                 counterparts who used the usual techniques like web and
                 code search, IDE code completion, and manual inspection
                 of library documentation. For the problem of API
                 migration, as a case study, we used MathFinder to
                 migrate Weka, a popular machine learning library.
                 Overall, our evaluation shows that MathFinder is easy
                 to use, provides highly precise results across several
                 math APIs and application domains even with a small
                 number of unit tests per method, and scales to large
                 collections of unit tests.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2014:CCD,
  author =       "Robert M. Hierons",
  title =        "Combining Centralised and Distributed Testing",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "5:1--5:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2661296",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 7 19:00:56 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Many systems interact with their environment at
                 distributed interfaces (ports) and sometimes it is not
                 possible to place synchronised local testers at the
                 ports of the system under test (SUT). There are then
                 two main approaches to testing: having independent
                 local testers or a single centralised tester that
                 interacts asynchronously with the SUT. The power of
                 using independent testers has been captured using
                 implementation relation dioco. In this article, we
                 define implementation relation diococ for the
                 centralised approach and prove that dioco and dioco$_c$
                 are incomparable. This shows that the frameworks detect
                 different types of faults and so we devise a hybrid
                 framework and define an implementation relation diocos
                 for this. We prove that the hybrid framework is more
                 powerful than the distributed and centralised
                 approaches. We then prove that the Oracle problem is
                 NP-complete for diococ and diocos but can be solved in
                 polynomial time if we place an upper bound on the
                 number of ports. Finally, we consider the problem of
                 deciding whether there is a test case that is
                 guaranteed to force a finite state model into a
                 particular state or to distinguish two states, proving
                 that both problems are undecidable for the centralised
                 and hybrid frameworks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sahin:2014:CSD,
  author =       "Dilan Sahin and Marouane Kessentini and Slim Bechikh
                 and Kalyanmoy Deb",
  title =        "Code-Smell Detection as a Bilevel Problem",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "1",
  pages =        "6:1--6:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2675067",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 14 17:48:15 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Code smells represent design situations that can
                 affect the maintenance and evolution of software. They
                 make the system difficult to evolve. Code smells are
                 detected, in general, using quality metrics that
                 represent some symptoms. However, the selection of
                 suitable quality metrics is challenging due to the
                 absence of consensus in identifying some code smells
                 based on a set of symptoms and also the high
                 calibration effort in determining manually the
                 threshold value for each metric. In this article, we
                 propose treating the generation of code-smell detection
                 rules as a bilevel optimization problem. Bilevel
                 optimization problems represent a class of challenging
                 optimization problems, which contain two levels of
                 optimization tasks. In these problems, only the optimal
                 solutions to the lower-level problem become possible
                 feasible candidates to the upper-level problem. In this
                 sense, the code-smell detection problem can be treated
                 as a bilevel optimization problem, but due to lack of
                 suitable solution techniques, it has been attempted to
                 be solved as a single-level optimization problem in the
                 past. In our adaptation here, the upper-level problem
                 generates a set of detection rules, a combination of
                 quality metrics, which maximizes the coverage of the
                 base of code-smell examples and artificial code smells
                 generated by the lower level. The lower level maximizes
                 the number of generated artificial code smells that
                 cannot be detected by the rules produced by the upper
                 level. The main advantage of our bilevel formulation is
                 that the generation of detection rules is not limited
                 to some code-smell examples identified manually by
                 developers that are difficult to collect, but it allows
                 the prediction of new code-smell behavior that is
                 different from those of the base of examples. The
                 statistical analysis of our experiments over 31 runs on
                 nine open-source systems and one industrial project
                 shows that seven types of code smells were detected
                 with an average of more than 86\% in terms of precision
                 and recall. The results confirm the outperformance of
                 our bilevel proposal compared to state-of-art
                 code-smell detection techniques. The evaluation
                 performed by software engineers also confirms the
                 relevance of detected code smells to improve the
                 quality of software systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2014:RIP,
  author =       "Kaituo Li and Christoph Reichenbach and Christoph
                 Csallner and Yannis Smaragdakis",
  title =        "Residual Investigation: Predictive and Precise Bug
                 Detection",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "7:1--7:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2656201",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We introduce the concept of residual investigation for
                 program analysis. A residual investigation is a dynamic
                 check installed as a result of running a static
                 analysis that reports a possible program error. The
                 purpose is to observe conditions that indicate whether
                 the statically predicted program fault is likely to be
                 realizable and relevant. The key feature of a residual
                 investigation is that it has to be much more precise
                 (i.e., with fewer false warnings) than the static
                 analysis alone, yet significantly more general (i.e.,
                 reporting more errors) than the dynamic tests in the
                 program's test suite that are pertinent to the
                 statically reported error. That is, good residual
                 investigations encode dynamic conditions that, when
                 considered in conjunction with the static error report,
                 increase confidence in the existence or severity of an
                 error without needing to directly observe a fault
                 resulting from the error. We enhance the static
                 analyzer FindBugs with several residual investigations
                 appropriately tuned to the static error patterns in
                 FindBugs, and apply it to nine large open-source
                 systems and their native test suites. The result is an
                 analysis with a low occurrence of false warnings (false
                 positives) while reporting several actual errors that
                 would not have been detected by mere execution of a
                 program's test suite.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fraser:2014:LSE,
  author =       "Gordon Fraser and Andrea Arcuri",
  title =        "A Large-Scale Evaluation of Automated Unit Test
                 Generation Using {EvoSuite}",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "8:1--8:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2685612",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Research on software testing produces many innovative
                 automated techniques, but because software testing is
                 by necessity incomplete and approximate, any new
                 technique faces the challenge of an empirical
                 assessment. In the past, we have demonstrated
                 scientific advance in automated unit test generation
                 with the E VOSUITE tool by evaluating it on manually
                 selected open-source projects or examples that
                 represent a particular problem addressed by the
                 underlying technique. However, demonstrating scientific
                 advance is not necessarily the same as demonstrating
                 practical value; even if VOSUITE worked well on the
                 software projects we selected for evaluation, it might
                 not scale up to the complexity of real systems.
                 Ideally, one would use large ``real-world'' software
                 systems to minimize the threats to external validity
                 when evaluating research tools. However, neither
                 choosing such software systems nor applying research
                 prototypes to them are trivial tasks. In this article
                 we present the results of a large experiment in unit
                 test generation using the VOSUITE tool on 100 randomly
                 chosen open-source projects, the 10 most popular
                 open-source projects according to the SourceForge Web
                 site, seven industrial projects, and 11 automatically
                 generated software projects. The study confirms that
                 VOSUITE can achieve good levels of branch coverage (on
                 average, 71\% per class) in practice. However, the
                 study also exemplifies how the choice of software
                 systems for an empirical study can influence the
                 results of the experiments, which can serve to inform
                 researchers to make more conscious choices in the
                 selection of software system subjects. Furthermore, our
                 experiments demonstrate how practical limitations
                 interfere with scientific advances, branch coverage on
                 an unbiased sample is affected by predominant
                 environmental dependencies. The surprisingly large
                 effect of such practical engineering problems in unit
                 testing will hopefully lead to a larger appreciation of
                 work in this area, thus supporting transfer of
                 knowledge from software testing research to practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{ElKholy:2014:CCR,
  author =       "Warda {El Kholy} and Jamal Bentahar and Mohamed {El
                 Menshawy} and Hongyang Qu and Rachida Dssouli",
  title =        "Conditional Commitments: Reasoning and Model
                 Checking",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "9:1--9:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2685613",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "While modeling interactions using social commitments
                 provides a fundamental basis for capturing flexible and
                 declarative interactions and helps in addressing the
                 challenge of ensuring compliance with specifications,
                 the designers of the system cannot guarantee that an
                 agent complies with its commitments as it is supposed
                 to, or at least an agent doesn't want to violate its
                 commitments. They may still wish to develop efficient
                 and scalable algorithms by which model checking
                 conditional commitments, a natural and universal frame
                 of social commitments, is feasible at design time.
                 However, distinguishing between different but related
                 types of conditional commitments, and developing
                 dedicated algorithms to tackle the problem of model
                 checking conditional commitments, is still an active
                 research topic. In this article, we develop the
                 temporal logic CTL$^{cc}$ that extends Computation Tree
                 Logic (CTL) with new modalities which allow
                 representing and reasoning about two types of
                 communicating conditional commitments and their
                 fulfillments using the formalism of interpreted
                 systems. We introduce a set of rules to reason about
                 conditional commitments and their fulfillments. The
                 verification technique is based on developing a new
                 symbolic model checking algorithm to address this
                 verification problem. We analyze the computational
                 complexity and present the full implementation of the
                 developed algorithm on top of the MCMAS model checker.
                 We also evaluate the algorithm's effectiveness and
                 scalability by verifying the compliance of the NetBill
                 protocol, taken from the business domain, and the
                 process of breast cancer diagnosis and treatment, taken
                 from the health-care domain, with specifications
                 expressed in CTL$^{cc}$. We finally compare the
                 experimental results with existing proposals.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hao:2014:UTC,
  author =       "Dan Hao and Lingming Zhang and Lu Zhang and Gregg
                 Rothermel and Hong Mei",
  title =        "A Unified Test Case Prioritization Approach",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "10:1--10:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2685614",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Test case prioritization techniques attempt to reorder
                 test cases in a manner that increases the rate at which
                 faults are detected during regression testing.
                 Coverage-based test case prioritization techniques
                 typically use one of two overall strategies: a total
                 strategy or an additional strategy. These strategies
                 prioritize test cases based on the total number of code
                 (or code-related) elements covered per test case and
                 the number of additional (not yet covered) code (or
                 code-related) elements covered per test case,
                 respectively. In this article, we present a unified
                 test case prioritization approach that encompasses both
                 the total and additional strategies. Our unified test
                 case prioritization approach includes two models (
                 basic and extended ) by which a spectrum of test case
                 prioritization techniques ranging from a purely total
                 to a purely additional technique can be defined by
                 specifying the value of a parameter referred to as the
                 $ f_p $ value. To evaluate our approach, we performed
                 an empirical study on 28 Java objects and 40 C objects,
                 considering the impact of three internal factors (model
                 type, choice of $ f_p $ value, and coverage type) and
                 three external factors (coverage granularity, test case
                 granularity, and programming/testing paradigm), all of
                 which can be manipulated by our approach. Our results
                 demonstrate that a wide range of techniques derived
                 from our basic and extended models with uniform $ f_p $
                 values can outperform purely total techniques and are
                 competitive with purely additional techniques.
                 Considering the influence of each internal and external
                 factor studied, the results demonstrate that various
                 values of each factor have nontrivial influence on test
                 case prioritization techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Eldib:2014:FVS,
  author =       "Hassan Eldib and Chao Wang and Patrick Schaumont",
  title =        "Formal Verification of Software Countermeasures
                 against Side-Channel Attacks",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "11:1--11:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2685616",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A common strategy for designing countermeasures
                 against power-analysis-based side-channel attacks is
                 using random masking techniques to remove the
                 statistical dependency between sensitive data and
                 side-channel emissions. However, this process is both
                 labor intensive and error prone and, currently, there
                 is a lack of automated tools to formally assess how
                 secure a countermeasure really is. We propose the first
                 SMT-solver-based method for formally verifying the
                 security of a masking countermeasure against such
                 attacks. In addition to checking whether the sensitive
                 data are masked by random variables, we also check
                 whether they are perfectly masked, that is, whether the
                 intermediate computation results in the implementation
                 of a cryptographic algorithm are independent of the
                 secret key. We encode this verification problem using a
                 series of quantifier-free first-order logic formulas,
                 whose satisfiability can be decided by an off-the-shelf
                 SMT solver. We have implemented the proposed method in
                 a software verification tool based on the LLVM compiler
                 frontend and the Yices SMT solver. Our experiments on a
                 set of recently proposed masking countermeasures for
                 cryptographic algorithms such as AES and MAC-Keccak
                 show the method is both effective in detecting power
                 side-channel leaks and scalable for practical use.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DeLara:2014:WHU,
  author =       "Juan {De Lara} and Esther Guerra and Jes{\'u}s
                 S{\'a}nchez Cuadrado",
  title =        "When and How to Use Multilevel Modelling",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "2",
  pages =        "12:1--12:??",
  month =        dec,
  year =         "2014",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2685615",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Jan 7 15:27:31 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model-Driven Engineering (MDE) promotes models as the
                 primary artefacts in the software development process,
                 from which code for the final application is derived.
                 Standard approaches to MDE (like those based on MOF or
                 EMF) advocate a two-level metamodelling setting where
                 Domain-Specific Modelling Languages (DSMLs) are defined
                 through a metamodel that is instantiated to build
                 models at the metalevel below. Multilevel modelling
                 (also called deep metamodelling ) extends the standard
                 approach to metamodelling by enabling modelling at an
                 arbitrary number of metalevels, not necessarily two.
                 Proposers of multilevel modelling claim this leads to
                 simpler model descriptions in some situations, although
                 its applicability has been scarcely evaluated. Thus,
                 practitioners may find it difficult to discern when to
                 use it and how to implement multilevel solutions in
                 practice. In this article, we discuss those situations
                 where the use of multilevel modelling is beneficial,
                 and identify recurring patterns and idioms. Moreover,
                 in order to assess how often the identified patterns
                 arise in practice, we have analysed a wide range of
                 existing two-level DSMLs from different sources and
                 domains, to detect when their elements could be
                 rearranged in more than two metalevels. The results
                 show this scenario is not uncommon, while in some
                 application domains (like software architecture and
                 enterprise/process modelling) pervasive, with a high
                 average number of pattern occurrences per metamodel.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yue:2015:AAF,
  author =       "Tao Yue and Lionel C. Briand and Yvan Labiche",
  title =        "{aToucan}: an Automated Framework to Derive {UML}
                 Analysis Models from Use Case Models",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "13:1--13:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2699697",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The transition from an informal requirements
                 specification in natural language to a structured,
                 precise specification is an important challenge in
                 practice. It is particularly so for object-oriented
                 methods, defined in the context of the OMG's Model
                 Driven Architecture (MDA), where a key step is to
                 transition from a use case model to an analysis model.
                 However, providing automated support for this
                 transition is challenging, mostly because, in practice,
                 requirements are expressed in natural language and are
                 much less structured than other kinds of development
                 artifacts. Such an automated transformation would
                 enable at least the generation of an initial, likely
                 incomplete, analysis model and enable automated
                 traceability from requirements to code, through various
                 intermediate models. In this article, we propose a
                 method and a tool called aToucan, building on existing
                 work, to automatically generate a UML analysis model
                 comprising class, sequence and activity diagrams from a
                 use case model and to automatically establish
                 traceability links between model elements of the use
                 case model and the generated analysis model. Note that
                 our goal is to save effort through automated support,
                 not to replace human abstraction and decision making.
                 Seven (six) case studies were performed to compare
                 class (sequence) diagrams generated by aToucan to the
                 ones created by experts, Masters students, and trained,
                 fourth-year undergraduate students. Results show that
                 aToucan performs well regarding consistency (e.g., 88\%
                 class diagram consistency) and completeness (e.g., 80\%
                 class completeness) when comparing generated class
                 diagrams with reference class diagrams created by
                 experts and Masters students. Similarly, sequence
                 diagrams automatically generated by aToucan are highly
                 consistent with the ones devised by experts and are
                 also rather complete, for instance, 91\% and 97\%
                 message consistency and completeness, respectively.
                 Further, statistical tests show that aToucan
                 significantly outperforms fourth-year engineering
                 students in this respect, thus demonstrating the value
                 of automation. We also conducted two industrial case
                 studies demonstrating the applicability of aToucan in
                 two different industrial domains. Results showed that
                 the vast majority of model elements generated by
                 aToucan are correct and that therefore, in practice,
                 such models would be good initial models to refine and
                 augment so as to converge towards to correct and
                 complete analysis models. A performance analysis shows
                 that the execution time of aToucan (when generating
                 class and sequence diagrams) is dependent on the number
                 of simple sentences contained in the use case model and
                 remains within a range of a few minutes. Five different
                 software system descriptions (18 use cases altogether)
                 were performed to evaluate the generation of activity
                 diagrams. Results show that aToucan can generate 100\%
                 complete and correct control flow information of
                 activity diagrams and on average 85\% data flAow
                 information completeness. Moreover, we show that
                 aToucan outperforms three commercial tools in terms of
                 activity diagram generation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Scanniello:2015:DDP,
  author =       "Giuseppe Scanniello and Carmine Gravino and Michele
                 Risi and Genoveffa Tortora and Gabriella Dodero",
  title =        "Documenting Design-Pattern Instances: a Family of
                 Experiments on Source-Code Comprehensibility",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "14:1--14:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2699696",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Design patterns are recognized as a means to improve
                 software maintenance by furnishing an explicit
                 specification of class and object interactions and
                 their underlying intent [Gamma et al. 1995]. Only a few
                 empirical investigations have been conducted to assess
                 whether the kind of documentation for design patterns
                 implemented in source code affects its
                 comprehensibility. To investigate this aspect, we
                 conducted a family of four controlled experiments with
                 88 participants having different experience (i.e.,
                 professionals and Bachelor, Master, and PhD students).
                 In each experiment, the participants were divided into
                 three groups and asked to comprehend a nontrivial chunk
                 of an open-source software system. Depending on the
                 group, each participant was, or was not, provided with
                 graphical or textual representations of the design
                 patterns implemented within the source code. We
                 graphically documented design-pattern instances with
                 UML class diagrams. Textually documented instances are
                 directly reported source code as comments. Our results
                 indicate that documenting design-pattern instances
                 yields an improvement in correctness of understanding
                 source code for those participants with an adequate
                 level of experience.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sherman:2015:DTB,
  author =       "Elena Sherman and Brady J. Garvin and Matthew B.
                 Dwyer",
  title =        "Deciding Type-Based Partial-Order Constraints for
                 Path-Sensitive Analysis",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "15:1--15:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2755971",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The precision and scalability of path-sensitive
                 program analyses depend on their ability to distinguish
                 feasible and infeasible program paths. Analyses express
                 path feasibility as the satisfiability of conjoined
                 branch conditions, which is then decided by cooperating
                 decision procedures such as those in satisfiability
                 modulo theory (SMT) solvers. Consequently, efficient
                 underlying decision procedures are key to precise,
                 scalable program analyses. When we investigate the
                 branch conditions accumulated by inter-procedural
                 path-sensitive analyses of object-oriented programs, we
                 find that many relate to an object's dynamic type.
                 These conditions arise from explicit type tests and the
                 branching implicit in dynamic dispatch and type
                 casting. These conditions share a common form that
                 comprises a fragment of the theory of partial orders,
                 which we refer to as type-based partial orders (TPO).
                 State-of-the-art SMT solvers can heuristically
                 instantiate the quantified formulae that axiomatize
                 partial orders, and thereby support TPO constraints. We
                 present two custom decision procedures with
                 significantly better performance. On benchmarks that
                 reflect inter-procedural path-sensitive analyses
                 applied to significant Java systems, the custom
                 procedures run three orders of magnitude faster. The
                 performance of the two decision procedures varies
                 across benchmarks, which suggests that a portfolio
                 approach may be beneficial for solving constraints
                 generated by program analyses.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Carzaniga:2015:AWE,
  author =       "Antonio Carzaniga and Alessandra Gorla and Nicol{\`o}
                 Perino and Mauro Pezz{\`e}",
  title =        "Automatic Workarounds: Exploiting the Intrinsic
                 Redundancy of {Web} Applications",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "16:1--16:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2755970",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Despite the best intentions, the competence, and the
                 rigorous methods of designers and developers, software
                 is often delivered and deployed with faults. To cope
                 with imperfect software, researchers have proposed the
                 concept of self-healing for software systems. The
                 ambitious goal is to create software systems capable of
                 detecting and responding ``autonomically'' to
                 functional failures, or perhaps even preempting such
                 failures, to maintain a correct functionality, possibly
                 with acceptable degradation. We believe that
                 self-healing can only be an expression of some form of
                 redundancy, meaning that, to automatically fix a faulty
                 behavior, the correct behavior must be already present
                 somewhere, in some form, within the software system
                 either explicitly or implicitly. One approach is to
                 deliberately design and develop redundant systems, and
                 in fact this kind of deliberate redundancy is the
                 essential ingredient of many fault tolerance
                 techniques. However, this type of redundancy is also
                 generally expensive and does not always satisfy the
                 time and cost constraints of many software projects.
                 With this article we take a different approach. We
                 observe that modern software systems naturally acquire
                 another type of redundancy that is not introduced
                 deliberately but rather arises intrinsically as a
                 by-product of modern modular software design. We
                 formulate this notion of intrinsic redundancy and we
                 propose a technique to exploit it to achieve some level
                 of self-healing. We first demonstrate that software
                 systems are indeed intrinsically redundant. Then we
                 develop a way to express and exploit this redundancy to
                 tolerate faults with automatic workarounds. In essence,
                 a workaround amounts to replacing some failing
                 operations with alternative operations that are
                 semantically equivalent in their intended effect, but
                 that execute different code and ultimately avoid the
                 failure. The technique we propose finds such
                 workarounds automatically. We develop this technique in
                 the context of Web applications. In particular, we
                 implement this technique within a browser extension,
                 which we then use in an evaluation with several known
                 faults and failures of three popular Web libraries. The
                 evaluation demonstrates that automatic workarounds are
                 effective: out of the nearly 150 real faults we
                 analyzed, 100 could be overcome with automatic
                 workarounds, and half of these workarounds found
                 automatically were not publicly known before.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mkaouer:2015:MOS,
  author =       "Wiem Mkaouer and Marouane Kessentini and Adnan Shaout
                 and Patrice Koligheu and Slim Bechikh and Kalyanmoy Deb
                 and Ali Ouni",
  title =        "Many-Objective Software Remodularization Using
                 {NSGA-III}",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "17:1--17:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2729974",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software systems nowadays are complex and difficult to
                 maintain due to continuous changes and bad design
                 choices. To handle the complexity of systems, software
                 products are, in general, decomposed in terms of
                 packages/modules containing classes that are dependent.
                 However, it is challenging to automatically
                 remodularize systems to improve their maintainability.
                 The majority of existing remodularization work mainly
                 satisfy one objective which is improving the structure
                 of packages by optimizing coupling and cohesion. In
                 addition, most of existing studies are limited to only
                 few operation types such as move class and split
                 packages. Many other objectives, such as the design
                 semantics, reducing the number of changes and
                 maximizing the consistency with development change
                 history, are important to improve the quality of the
                 software by remodularizing it. In this article, we
                 propose a novel many-objective search-based approach
                 using NSGA-III. The process aims at finding the optimal
                 remodularization solutions that improve the structure
                 of packages, minimize the number of changes, preserve
                 semantics coherence, and reuse the history of changes.
                 We evaluate the efficiency of our approach using four
                 different open-source systems and one automotive
                 industry project, provided by our industrial partner,
                 through a quantitative and qualitative study conducted
                 with software engineers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yi:2015:SCC,
  author =       "Jooyong Yi and Dawei Qi and Shin Hwei Tan and Abhik
                 Roychoudhury",
  title =        "Software Change Contracts",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "18:1--18:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2729973",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software errors often originate from incorrect
                 changes, including incorrect program fixes, incorrect
                 feature updates, and so on. Capturing the intended
                 program behavior explicitly via contracts is thus an
                 attractive proposition. In our recent work, we had
                 espoused the notion of ``change contracts'' to express
                 the intended program behavior changes across program
                 versions. Change contracts differ from program
                 contracts in that they do not require the programmer to
                 describe the intended behavior of those program
                 features which are unchanged across program versions.
                 In this work, we present the formal semantics of our
                 change contract language built on top of the Java
                 modeling language (JML). Our change contract language
                 can describe behavioral as well as structural changes.
                 We evaluate the expressivity of the change contract
                 language via a survey given to final-year undergraduate
                 students. The survey results enable to understand the
                 usability of our change contract language for purposes
                 of writing contracts, comprehending written contracts,
                 and modifying programs according to given change
                 contracts. Finally, we develop both dynamic and static
                 checkers for change contracts, and show how they can be
                 used in maintaining software changes. We use our
                 dynamic checker to automatically suggest tests that
                 manifest violations of change contracts. Meanwhile, we
                 use our static checker to verify that a program is
                 changed as specified in its change contract. Apart from
                 verification, our static checker also performs various
                 other software engineering tasks, such as localizing
                 the buggy method, detecting/debugging regression
                 errors, and classifying the cause for a test failure as
                 either error in production code or error in test
                 code.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Murukannaiah:2015:PAL,
  author =       "Pradeep K. Murukannaiah and Munindar P. Singh",
  title =        "{Platys}: an Active Learning Framework for Place-Aware
                 Application Development and Its Evaluation",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "19:1--19:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2729976",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We introduce a high-level abstraction of location
                 called place. A place derives its meaning from a user's
                 physical space, activities, or social context. In this
                 manner, place can facilitate improved user experience
                 compared to the traditional representation of location,
                 which is spatial coordinates. We propose the Platys
                 framework as a way to address the special challenges of
                 place-aware application development. The core of Platys
                 is a middleware that (1) learns a model of places
                 specific to each user via active learning, a machine
                 learning paradigm that seeks to reduce the user-effort
                 required for training the middleware, and (2) exposes
                 the learned user-specific model of places to
                 applications at run time, insulating application
                 developers from dealing with both low-level sensors and
                 user idiosyncrasies in perceiving places. We evaluated
                 Platys via two studies. First, we collected place
                 labels and Android phone sensor readings from 10 users.
                 We applied Platys' active learning approach to learn
                 each user's places and found that Platys (1) requires
                 fewer place labels to learn a user's places with a
                 desired accuracy than do two traditional supervised
                 approaches, and (2) learns places with higher accuracy
                 than two unsupervised approaches. Second, we conducted
                 a developer study to evaluate Platys' efficiency in
                 assisting developers and its effectiveness in enabling
                 usable applications. In this study, 46 developers
                 employed either Platys or the Android location API to
                 develop a place-aware application. Our results indicate
                 that application developers employing Platys, when
                 compared to those employing the Android API, (1)
                 develop a place-aware application faster and perceive
                 reduced difficulty and (2) produce applications that
                 are easier to understand (for developers) and
                 potentially more usable and privacy preserving (for
                 application users).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Whigham:2015:BMS,
  author =       "Peter A. Whigham and Caitlin A. Owen and Stephen G.
                 Macdonell",
  title =        "A Baseline Model for Software Effort Estimation",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "3",
  pages =        "20:1--20:??",
  month =        may,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2738037",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed May 13 18:25:46 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software effort estimation (SEE) is a core activity in
                 all software processes and development lifecycles. A
                 range of increasingly complex methods has been
                 considered in the past 30 years for the prediction of
                 effort, often with mixed and contradictory results. The
                 comparative assessment of effort prediction methods has
                 therefore become a common approach when considering how
                 best to predict effort over a range of project types.
                 Unfortunately, these assessments use a variety of
                 sampling methods and error measurements, making
                 comparison with other work difficult. This article
                 proposes an automatically transformed linear model
                 (ATLM) as a suitable baseline model for comparison
                 against SEE methods. ATLM is simple yet performs well
                 over a range of different project types. In addition,
                 ATLM may be used with mixed numeric and categorical
                 data and requires no parameter tuning. It is also
                 deterministic, meaning that results obtained are
                 amenable to replication. These and other arguments for
                 using ATLM as a baseline model are presented, and a
                 reference implementation described and made available.
                 We suggest that ATLM should be used as a baseline of
                 effort prediction quality for all future model
                 comparisons in SEE.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Harman:2015:ISI,
  author =       "Mark Harman and Mauro Pezz{\'e}",
  title =        "Introduction to the Special Issue on {ISSTA 2013}",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "21:1--21:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2809789",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gligoric:2015:GCB,
  author =       "Milos Gligoric and Alex Groce and Chaoqiang Zhang and
                 Rohan Sharma and Mohammad Amin Alipour and Darko
                 Marinov",
  title =        "Guidelines for Coverage-Based Comparisons of
                 Non-Adequate Test Suites",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "22:1--22:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2660767",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A fundamental question in software testing research is
                 how to compare test suites, often as a means for
                 comparing test-generation techniques that produce those
                 test suites. Researchers frequently compare test suites
                 by measuring their coverage. A coverage criterion C
                 provides a set of test requirements and measures how
                 many requirements a given suite satisfies. A suite that
                 satisfies 100\% of the feasible requirements is called
                 C-adequate. Previous rigorous evaluations of coverage
                 criteria mostly focused on such adequate test suites:
                 given two criteria C and C', are C-adequate suites on
                 average more effective than C'-adequate suites?
                 However, in many realistic cases, producing adequate
                 suites is impractical or even impossible. This article
                 presents the first extensive study that evaluates
                 coverage criteria for the common case of non-adequate
                 test suites: given two criteria C and C', which one is
                 better to use to compare test suites? Namely, if suites
                 T$_1$, T$_2$,\ldots{}, T$_n$ have coverage values $ c_1$, $
                 c_2$,\ldots{}, $ c_n$ for C and $ c_1 '$, $ c_2 '$,\ldots{}, $
                 c_n'$ for C', is it better to compare suites based on $
                 c_1$, $ c_2$,\ldots{}, $ c_n$ or based on $ c_1 '$, $ c_2 '$
                 \ldots{}, $ c_n'$ ? We evaluate a large set of
                 plausible criteria, including basic criteria such as
                 statement and branch coverage, as well as stronger
                 criteria used in recent studies, including criteria
                 based on program paths, equivalence classes of covered
                 statements, and predicate states. The criteria are
                 evaluated on a set of Java and C programs with both
                 manually written and automatically generated test
                 suites. The evaluation uses three correlation measures.
                 Based on these experiments, two criteria perform best:
                 branch coverage and an intraprocedural acyclic path
                 coverage. We provide guidelines for testing researchers
                 aiming to evaluate test suites using coverage criteria
                 as well as for other researchers evaluating coverage
                 criteria for research use.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fraser:2015:DAU,
  author =       "Gordon Fraser and Matt Staats and Phil McMinn and
                 Andrea Arcuri and Frank Padberg",
  title =        "Does Automated Unit Test Generation Really Help
                 Software Testers? {A} Controlled Empirical Study",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "23:1--23:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2699688",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Work on automated test generation has produced several
                 tools capable of generating test data which achieves
                 high structural coverage over a program. In the absence
                 of a specification, developers are expected to manually
                 construct or verify the test oracle for each test
                 input. Nevertheless, it is assumed that these generated
                 tests ease the task of testing for the developer, as
                 testing is reduced to checking the results of tests.
                 While this assumption has persisted for decades, there
                 has been no conclusive evidence to date confirming it.
                 However, the limited adoption in industry indicates
                 this assumption may not be correct, and calls into
                 question the practical value of test generation tools.
                 To investigate this issue, we performed two controlled
                 experiments comparing a total of 97 subjects split
                 between writing tests manually and writing tests with
                 the aid of an automated unit test generation tool, E
                 voSuite. We found that, on one hand, tool support leads
                 to clear improvements in commonly applied quality
                 metrics such as code coverage (up to 300\% increase).
                 However, on the other hand, there was no measurable
                 improvement in the number of bugs actually found by
                 developers. Our results not only cast some doubt on how
                 the research community evaluates test generation tools,
                 but also point to improvements and future work
                 necessary before automated test generation tools will
                 be widely adopted by practitioners.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Radoi:2015:ETS,
  author =       "Cosmin Radoi and Danny Dig",
  title =        "Effective Techniques for Static Race Detection in
                 {Java} Parallel Loops",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "24:1--24:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2729975",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Despite significant progress in recent years, the
                 important problem of static race detection remains
                 open. Previous techniques took a general approach and
                 looked for races by analyzing the effects induced by
                 low-level concurrency constructs (e.g.,
                 java.lang.Thread). But constructs and libraries for
                 expressing parallelism at a higher level (e.g.,
                 fork-join, futures, parallel loops) are becoming
                 available in all major programming languages. We claim
                 that specializing an analysis to take advantage of the
                 extra semantic information provided by the use of these
                 constructs and libraries improves precision and
                 scalability. We present I teRace, a set of techniques
                 that are specialized to use the intrinsic thread,
                 safety, and dataflow structure of collections and of
                 the new loop parallelism mechanism introduced in Java
                 8. Our evaluation shows that IteRace is fast and
                 precise enough to be practical. It scales to programs
                 of hundreds of thousands of lines of code and reports
                 very few race warnings, thus avoiding a common pitfall
                 of static analyses. In five out of the seven case
                 studies, IteRace reported no false warnings. Also, it
                 revealed six bugs in real-world applications. We
                 reported four of them: one had already been fixed, and
                 three were new and the developers confirmed and fixed
                 them. Furthermore, we evaluate the effect of each
                 specialization technique on the running time and
                 precision of the analysis. For each application, we run
                 the analysis under 32 different configurations. This
                 allows to analyze each technique's effect both alone
                 and in all possible combinations with other
                 techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nijjar:2015:DMP,
  author =       "Jaideep Nijjar and Ivan Boci{\'c} and Tevfik Bultan",
  title =        "Data Model Property Inference, Verification, and
                 Repair for {Web} Applications",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "25:1--25:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2699691",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Most software systems nowadays are Web-based
                 applications that are deployed over compute clouds
                 using a three-tier architecture, where the persistent
                 data for the application is stored in a backend
                 datastore and is accessed and modified by the
                 server-side code based on the user interactions at the
                 client-side. The data model forms the foundation of
                 these three tiers, and identifies the sets of objects
                 (object classes) and the relations among them
                 (associations among object classes) stored by the
                 application. In this article, we present a set of
                 property patterns to specify properties of a data
                 model, as well as several heuristics for automatically
                 inferring them. We show that the specified or inferred
                 data model properties can be automatically verified
                 using bounded and unbounded verification techniques.
                 For the properties that fail, we present techniques
                 that generate fixes to the data model that establish
                 the failing properties. We implemented this approach
                 for Web applications built using the Ruby on Rails
                 framework and applied it to ten open source
                 applications. Our experimental results demonstrate that
                 our approach is effective in automatically identifying
                 and fixing errors in data models of real-world web
                 applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jin:2015:ASR,
  author =       "Wei Jin and Alessandro Orso",
  title =        "Automated Support for Reproducing and Debugging Field
                 Failures",
  journal =      j-TOSEM,
  volume =       "24",
  number =       "4",
  pages =        "26:1--26:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2774218",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Sep 8 18:21:02 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "As confirmed by a recent survey conducted among
                 developers of the Apache, Eclipse, and Mozilla
                 projects, two extremely challenging tasks during
                 maintenance are reproducing and debugging field
                 failures-failures that occur on user machines after
                 release. To help developers with these tasks, in this
                 article we present an overall approach that comprises
                 two different techniques: B ugRedux and F$^3$. BugRedux
                 is a general technique for reproducing field failures
                 that collects dynamic data about failing executions in
                 the field and uses this data to synthesize executions
                 that mimic the observed field failures. F$^3$ leverages
                 the executions generated by BugRedux to perform
                 automated debugging using a set of suitably optimized
                 fault-localization techniques. To assess the usefulness
                 of our approach, we performed an empirical evaluation
                 of the approach on a set of real-world programs and
                 field failures. The results of our evaluation are
                 promising in that, for all the failures considered, our
                 approach was able to (1) synthesize failing executions
                 that mimicked the observed field failures, (2)
                 synthesize passing executions similar to the failing
                 ones, and (3) use the synthesized executions to
                 successfully perform fault localization with accurate
                 results.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dwyer:2015:EJF,
  author =       "Matthew B. Dwyer and David S. Rosenblum",
  title =        "Editorial: Journal-First Publication for the Software
                 Engineering Community",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "1:1--1:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2837717",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dietz:2015:UIO,
  author =       "Will Dietz and Peng Li and John Regehr and Vikram
                 Adve",
  title =        "Understanding Integer Overflow in {C\slash C++}",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "2:1--2:29",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2743019",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Integer overflow bugs in C and C++ programs are
                 difficult to track down and may lead to fatal errors or
                 exploitable vulnerabilities. Although a number of tools
                 for finding these bugs exist, the situation is
                 complicated because not all overflows are bugs. Better
                 tools need to be constructed, but a thorough
                 understanding of the issues behind these errors does
                 not yet exist. We developed IOC, a dynamic checking
                 tool for integer overflows, and used it to conduct the
                 first detailed empirical study of the prevalence and
                 patterns of occurrence of integer overflows in C and
                 C++ code. Our results show that intentional uses of
                 wraparound behaviors are more common than is widely
                 believed; for example, there are over 200 distinct
                 locations in the SPEC CINT2000 benchmarks where
                 overflow occurs. Although many overflows are
                 intentional, a large number of accidental overflows
                 also occur. Orthogonal to programmers' intent,
                 overflows are found in both well-defined and undefined
                 flavors. Applications executing undefined operations
                 can be, and have been, broken by improvements in
                 compiler optimizations. Looking beyond SPEC, we found
                 and reported undefined integer overflows in SQLite,
                 PostgreSQL, SafeInt, GNU MPC and GMP, Firefox, LLVM,
                 Python, BIND, and OpenSSL; many of these have since
                 been fixed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Proksch:2015:ICC,
  author =       "Sebastian Proksch and Johannes Lerch and Mira Mezini",
  title =        "Intelligent Code Completion with {Bayesian} Networks",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "3:1--3:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2744200",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Code completion is an integral part of modern
                 Integrated Development Environments (IDEs). Developers
                 often use it to explore Application Programming
                 Interfaces (APIs). It is also useful to reduce the
                 required amount of typing and to help avoid typos.
                 Traditional code completion systems propose all
                 type-correct methods to the developer. Such a list is
                 often very long with many irrelevant items. More
                 intelligent code completion systems have been proposed
                 in prior work to reduce the list of proposed methods to
                 relevant items. This work extends one of these existing
                 approaches, the Best Matching Neighbor (BMN) algorithm.
                 We introduce Bayesian networks as an alternative
                 underlying model, use additional context information
                 for more precise recommendations, and apply clustering
                 techniques to improve model sizes. We compare our new
                 approach, Pattern-based Bayesian Networks (PBN), to the
                 existing BMN algorithm. We extend previously used
                 evaluation methodologies and, in addition to prediction
                 quality, we also evaluate model size and inference
                 speed. Our results show that the additional context
                 information we collect improves prediction quality,
                 especially for queries that do not contain method
                 calls. We also show that PBN can obtain comparable
                 prediction quality to BMN, while model size and
                 inference speed scale better with large input sizes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Alesio:2015:CGA,
  author =       "Stefano {Di Alesio} and Lionel C. Briand and Shiva
                 Nejati and Arnaud Gotlieb",
  title =        "Combining Genetic Algorithms and Constraint
                 Programming to Support Stress Testing of Task
                 Deadlines",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "4:1--4:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2818640",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Tasks in real-time embedded systems (RTES) are often
                 subject to hard deadlines that constrain how quickly
                 the system must react to external inputs. These inputs
                 and their timing vary in a large domain depending on
                 the environment state and can never be fully predicted
                 prior to system execution. Therefore, approaches for
                 stress testing must be developed to uncover possible
                 deadline misses of tasks for different input arrival
                 times. In this article, we describe stress-test case
                 generation as a search problem over the space of task
                 arrival times. Specifically, we search for worst-case
                 scenarios maximizing deadline misses, where each
                 scenario characterizes a test case. In order to scale
                 our search to large industrial-size problems, we
                 combine two state-of-the-art search strategies, namely,
                 genetic algorithms (GA) and constraint programming
                 (CP). Our experimental results show that, in comparison
                 with GA and CP in isolation, GA+CP achieves nearly the
                 same effectiveness as CP and the same efficiency and
                 solution diversity as GA, thus combining the advantages
                 of the two strategies. In light of these results, we
                 conclude that a combined GA+CP approach to stress
                 testing is more likely to scale to large and complex
                 systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ceccato:2015:DAG,
  author =       "Mariano Ceccato and Alessandro Marchetto and Leonardo
                 Mariani and Cu D. Nguyen and Paolo Tonella",
  title =        "Do Automatically Generated Test Cases Make Debugging
                 Easier? {An} Experimental Assessment of Debugging
                 Effectiveness and Efficiency",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "5:1--5:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2768829",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Several techniques and tools have been proposed for
                 the automatic generation of test cases. Usually, these
                 tools are evaluated in terms of fault-revealing or
                 coverage capability, but their impact on the manual
                 debugging activity is not considered. The question is
                 whether automatically generated test cases are equally
                 effective in supporting debugging as manually written
                 tests. We conducted a family of three experiments (five
                 replications) with humans (in total, 55 subjects) to
                 assess whether the features of automatically generated
                 test cases, which make them less readable and
                 understandable (e.g., unclear test scenarios,
                 meaningless identifiers), have an impact on the
                 effectiveness and efficiency of debugging. The first
                 two experiments compare different test case generation
                 tools (Randoop vs. EvoSuite). The third experiment
                 investigates the role of code identifiers in test cases
                 (obfuscated vs. original identifiers), since a major
                 difference between manual and automatically generated
                 test cases is that the latter contain meaningless
                 (obfuscated) identifiers. We show that automatically
                 generated test cases are as useful for debugging as
                 manual test cases. Furthermore, we find that, for less
                 experienced developers, automatic tests are more useful
                 on average due to their lower static and dynamic
                 complexity.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Emam:2015:TCP,
  author =       "Seyedeh Sepideh Emam and James Miller",
  title =        "Test Case Prioritization Using Extended Digraphs",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "6:1--6:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2789209",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Although many test case prioritization techniques
                 exist, their performance is far from perfect. Hence, we
                 propose a new fault-based test case prioritization
                 technique to promote fault-revealing test cases in
                 model-based testing (MBT) procedures. We seek to
                 improve the fault detection rate-a measure of how fast
                 a test suite is able to detect faults during testing-in
                 scenarios such as regression testing. We propose an
                 extended digraph model as the basis of this new
                 technique. The model is realized using a novel
                 reinforcement-learning (RL)- and hidden-Markov-model
                 (HMM)-based technique which is able to prioritize test
                 cases for regression testing objectives. We present a
                 method to initialize and train an HMM based upon RL
                 concepts applied to an application's digraph model. The
                 model prioritizes test cases based upon forward
                 probabilities, a new test case prioritization approach.
                 In addition, we also propose an alternative approach to
                 prioritizing test cases according to the amount of
                 change they cause in applications. To evaluate the
                 effectiveness of the proposed techniques, we perform
                 experiments on graphical user interface (GUI)-based
                 applications and compare the results with
                 state-of-the-art test case prioritization approaches.
                 The experimental results show that the proposed
                 technique is able to detect faults early within test
                 runs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dyer:2015:BUL,
  author =       "Robert Dyer and Hoan Anh Nguyen and Hridesh Rajan and
                 Tien N. Nguyen",
  title =        "{Boa}: Ultra-Large-Scale Software Repository and
                 Source-Code Mining",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "7:1--7:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2803171",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "In today's software-centric world, ultra-large-scale
                 software repositories, such as SourceForge, GitHub, and
                 Google Code, are the new library of Alexandria. They
                 contain an enormous corpus of software and related
                 information. Scientists and engineers alike are
                 interested in analyzing this wealth of information.
                 However, systematic extraction and analysis of relevant
                 data from these repositories for testing hypotheses is
                 hard, and best left for mining software repository
                 (MSR) experts! Specifically, mining source code yields
                 significant insights into software development
                 artifacts and processes. Unfortunately, mining source
                 code at a large scale remains a difficult task.
                 Previous approaches had to either limit the scope of
                 the projects studied, limit the scope of the mining
                 task to be more coarse grained, or sacrifice studying
                 the history of the code. In this article we address
                 mining source code: (a) at a very large scale; (b) at a
                 fine-grained level of detail; and (c) with full history
                 information. To address these challenges, we present
                 domain-specific language features for source-code
                 mining in our language and infrastructure called Boa.
                 The goal of Boa is to ease testing MSR-related
                 hypotheses. Our evaluation demonstrates that Boa
                 substantially reduces programming efforts, thus
                 lowering the barrier to entry. We also show drastic
                 improvements in scalability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mcminn:2015:ETC,
  author =       "Phil Mcminn and Chris J. Wright and Gregory M.
                 Kapfhammer",
  title =        "The Effectiveness of Test Coverage Criteria for
                 Relational Database Schema Integrity Constraints",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "8:1--8:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2818639",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Despite industry advice to the contrary, there has
                 been little work that has sought to test that a
                 relational database's schema has correctly specified
                 integrity constraints. These critically important
                 constraints ensure the coherence of data in a database,
                 defending it from manipulations that could violate
                 requirements such as ``usernames must be unique'' or
                 ``the host name cannot be missing or unknown.'' This
                 article is the first to propose coverage criteria,
                 derived from logic coverage criteria, that establish
                 different levels of testing for the formulation of
                 integrity constraints in a database schema. These range
                 from simple criteria that mandate the testing of
                 successful and unsuccessful INSERT statements into
                 tables to more advanced criteria that test the
                 formulation of complex integrity constraints such as
                 multi-column PRIMARY KEYs and arbitrary CHECK
                 constraints. Due to different vendor interpretations of
                 the structured query language (SQL) specification with
                 regard to how integrity constraints should actually
                 function in practice, our criteria crucially account
                 for the underlying semantics of the database management
                 system (DBMS). After formally defining these coverage
                 criteria and relating them in a subsumption hierarchy,
                 we present two approaches for automatically generating
                 tests that satisfy the criteria. We then describe the
                 results of an empirical study that uses mutation
                 analysis to investigate the fault-finding capability of
                 data generated when our coverage criteria are applied
                 to a wide variety of relational schemas hosted by three
                 well-known and representative DBMSs-HyperSQL,
                 PostgreSQL, and SQLite. In addition to revealing the
                 complementary fault-finding capabilities of the
                 presented criteria, the results show that mutation
                 scores range from as low as just 12\% of mutants being
                 killed with the simplest of criteria to 96\% with the
                 most advanced.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ali:2015:TBC,
  author =       "Karim Ali and Marianna Rapoport and Ondrej Lhot{\'a}k
                 and Julian Dolby and Frank Tip",
  title =        "Type-Based Call Graph Construction Algorithms for
                 {Scala}",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "9:1--9:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2824234",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Call graphs have many applications in software
                 engineering. For example, they serve as the basis for
                 code navigation features in integrated development
                 environments and are at the foundation of static
                 analyses performed in verification tools. While many
                 call graph construction algorithms have been presented
                 in the literature, we are not aware of any that handle
                 Scala features such as traits and abstract type
                 members. Applying existing algorithms to the JVM
                 bytecodes generated by the Scala compiler produces very
                 imprecise results because type information is lost
                 during compilation. We adapt existing type-based call
                 graph construction algorithms to Scala and present a
                 formalization based on Featherweight Scala. An
                 experimental evaluation shows that our most precise
                 algorithm generates call graphs with 1.1--3.7 times
                 fewer nodes and 1.5--17.3 times fewer edges than a
                 bytecode-based RTA analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mahmoud:2015:ESR,
  author =       "Anas Mahmoud and Gary Bradshaw",
  title =        "Estimating Semantic Relatedness in Source Code",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "1",
  pages =        "10:1--10:??",
  month =        dec,
  year =         "2015",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2824251",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Dec 3 09:54:19 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Contemporary software engineering tools exploit
                 semantic relations between individual code terms to aid
                 in code analysis and retrieval tasks. Such tools employ
                 word similarity methods, often used in natural language
                 processing ( nlp), to analyze the textual content of
                 source code. However, the notion of similarity in
                 source code is different from natural language. Source
                 code often includes unnatural domain-specific terms
                 (e.g., abbreviations and acronyms), and such terms
                 might be related due to their structural relations
                 rather than linguistic aspects. Therefore, applying
                 natural language similarity methods to source code
                 without adjustment can produce low-quality and
                 error-prone results. Motivated by these observations,
                 we systematically investigate the performance of
                 several semantic-relatedness methods in the context of
                 software. Our main objective is to identify the most
                 effective semantic schemes in capturing association
                 relations between source code terms. To provide an
                 unbiased comparison, different methods are compared
                 against human-generated relatedness information using
                 terms from three software systems. Results show that
                 corpus-based methods tend to outperform methods that
                 exploit external sources of semantic knowledge.
                 However, due to inherent code limitations, the
                 performance of such methods is still suboptimal. To
                 address these limitations, we propose Normalized
                 Software Distance (nsd), an information-theoretic
                 method that captures semantic relatedness in source
                 code by exploiting the distributional cues of code
                 terms across the system. nsd overcomes data sparsity
                 and lack of context problems often associated with
                 source code, achieving higher levels of resemblance to
                 the human perception of relatedness at the term and the
                 text levels of code.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2016:E,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "11:1--11:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2904898",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Alimadadi:2016:UJE,
  author =       "Saba Alimadadi and Sheldon Sequeira and Ali Mesbah and
                 Karthik Pattabiraman",
  title =        "Understanding {JavaScript} Event-Based Interactions
                 with {Clematis}",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "12:1--12:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2876441",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Web applications have become one of the
                 fastest-growing types of software systems today.
                 Despite their popularity, understanding the behavior of
                 modern web applications is still a challenging endeavor
                 for developers during development and maintenance
                 tasks. The challenges mainly stem from the dynamic,
                 event-driven, and asynchronous nature of the JavaScript
                 language. We propose a generic technique for capturing
                 low-level event-based interactions in a web application
                 and mapping those to a higher-level behavioral model.
                 This model is then transformed into an interactive
                 visualization, representing episodes of triggered
                 causal and temporal events, related JavaScript code
                 executions, and their impact on the dynamic DOM state.
                 Our approach, implemented in a tool called Clematis,
                 allows developers to easily understand the complex
                 dynamic behavior of their application at three
                 different semantic levels of granularity. Furthermore,
                 Clematis helps developers bridge the gap between test
                 cases and program code by localizing the fault related
                 to a test assertion. The results of our industrial
                 controlled experiment show that Clematis is capable of
                 improving the comprehension task accuracy by 157\%
                 while reducing the task completion time by 47\%. A
                 follow-up experiment reveals that Clematis improves the
                 fault localization accuracy of developers by a factor
                 of two.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2016:IRO,
  author =       "Minghui Zhou and Audris Mockus and Xiujuan Ma and Lu
                 Zhang and Hong Mei",
  title =        "Inflow and Retention in {OSS} Communities with
                 Commercial Involvement: a Case Study of Three Hybrid
                 Projects",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "13:1--13:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2876443",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Motivation: Open-source projects are often supported
                 by companies, but such involvement often affects the
                 robust contributor inflow needed to sustain the project
                 and sometimes prompts key contributors to leave. To
                 capture user innovation and to maintain quality of
                 software and productivity of teams, these projects need
                 to attract and retain contributors. Aim: We want to
                 understand and quantify how inflow and retention are
                 shaped by policies and actions of companies in three
                 application server projects. Method: We identified
                 three hybrid projects implementing the same JavaEE
                 specification and used published literature, online
                 materials, and interviews to quantify actions and
                 policies companies used to get involved. We collected
                 project repository data, analyzed affiliation history
                 of project participants, and used generalized linear
                 models and survival analysis to measure contributor
                 inflow and retention. Results: We identified coherent
                 groups of policies and actions undertaken by sponsoring
                 companies as three models of community involvement and
                 quantified tradeoffs between the inflow and retention
                 each model provides. We found that full control
                 mechanisms and high intensity of commercial involvement
                 were associated with a decrease of external inflow and
                 with improved retention. However, a shared control
                 mechanism was associated with increased external inflow
                 contemporaneously with the increase of commercial
                 involvement. Implications: Inspired by a natural
                 experiment, our methods enabled us to quantify aspects
                 of the balance between community and private interests
                 in open- source software projects and provide clear
                 implications for the structure of future open-source
                 communities.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Machado:2016:CDD,
  author =       "Nuno Machado and Daniel Quinta and Brandon Lucia and
                 Lu{\'\i}s Rodrigues",
  title =        "Concurrency Debugging with Differential Schedule
                 Projections",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "14:1--14:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2885495",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present Symbiosis: a concurrency debugging
                 technique based on novel differential schedule
                 projections (DSPs). A DSP shows the small set of memory
                 operations and dataflows responsible for a failure, as
                 well as a reordering of those elements that avoids the
                 failure. To build a DSP, Symbiosis first generates a
                 full, failing, multithreaded schedule via thread path
                 profiling and symbolic constraint solving. Symbiosis
                 selectively reorders events in the failing schedule to
                 produce a nonfailing, alternate schedule. A DSP reports
                 the ordering and dataflow differences between the
                 failing and nonfailing schedules. Our evaluation on
                 buggy real-world software and benchmarks shows that, in
                 practical time, Symbiosis generates DSPs that both
                 isolate the small fraction of event orders and
                 dataflows responsible for the failure and report which
                 event reorderings prevent failing. In our experiments,
                 DSPs contain 90\% fewer events and 96\% fewer dataflows
                 than the full failure-inducing schedules. We also
                 conducted a user study that shows that, by allowing
                 developers to focus on only a few events, DSPs reduce
                 the amount of time required to understand the bug's
                 root cause and find a valid fix.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bauch:2016:CED,
  author =       "Petr Bauch and Vojtech Havel and Jir{\'\i} Barnat",
  title =        "Control Explicit-Data Symbolic Model Checking",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "15:1--15:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2888393",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Automatic verification of programs and computer
                 systems with data nondeterminism (e.g., reading from
                 user input) represents a significant and well-motivated
                 challenge. The case of parallel programs is especially
                 difficult, because then also the control flow
                 nontrivially complicates the verification process. We
                 apply the techniques of explicit-state model checking
                 to account for the control aspects of a program to be
                 verified and use set-based reduction of the data flow,
                 thus handling the two sources of nondeterminism
                 separately. We build the theory of set-based reduction
                 using first-order formulae in the bit-vector theory to
                 encode the sets of variable evaluations representing
                 program data. These representations are tested for
                 emptiness and equality (state matching) during the
                 verification, and we harness modern satisfiability
                 modulo theory solvers to implement these tests. We
                 design two methods of implementing the state matching,
                 one using quantifiers and one that is quantifier-free,
                 and we provide both analytical and experimental
                 comparisons. Further experiments evaluate the
                 efficiency of the set-based reduction method, showing
                 the classical, explicit approach to fail to scale with
                 the size of data domains. Finally, we propose and
                 evaluate two heuristics to decrease the number of
                 expensive satisfiability queries, together yielding a
                 10-fold speedup.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pavese:2016:LME,
  author =       "Esteban Pavese and V{\'\i}ctor Braberman and Sebastian
                 Uchitel",
  title =        "Less is More: Estimating Probabilistic Rewards over
                 Partial System Explorations",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "16:1--16:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2890494",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model-based reliability estimation of systems can
                 provide useful insights early in the development
                 process. However, computational complexity of
                 estimating metrics such as mean time to first failure
                 (MTTFF), turnaround time (TAT), or other domain-based
                 quantitative measures can be prohibitive both in time,
                 space, and precision. In this article, we present an
                 alternative to exhaustive model exploration, as in
                 probabilistic model checking, and partial random
                 exploration, as in statistical model checking. Our
                 hypothesis is that a (carefully crafted) partial
                 systematic exploration of a system model can provide
                 better bounds for these quantitative model metrics at
                 lower computation cost. We present a novel automated
                 technique for metric estimation that combines
                 simulation, invariant inference, and probabilistic
                 model checking. Simulation produces a probabilistically
                 relevant set of traces from which a state invariant is
                 inferred. The invariant characterises a partial model,
                 which is then exhaustively explored using probabilistic
                 model checking. We report on experiments that suggest
                 that metric estimation using this technique (for both
                 fully probabilistic models and those exhibiting
                 nondeterminism) can be more effective than (full-model)
                 probabilistic and statistical model checking,
                 especially for system models for which the events of
                 interest are rare.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2016:SOP,
  author =       "Robert M. Hierons and Miqing Li and Xiaohui Liu and
                 Sergio Segura and Wei Zheng",
  title =        "{SIP}: Optimal Product Selection from Feature Models
                 Using Many-Objective Evolutionary Optimization",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "17:1--17:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2897760",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A feature model specifies the sets of features that
                 define valid products in a software product line.
                 Recent work has considered the problem of choosing
                 optimal products from a feature model based on a set of
                 user preferences, with this being represented as a
                 many-objective optimization problem. This problem has
                 been found to be difficult for a purely search-based
                 approach, leading to classical many-objective
                 optimization algorithms being enhanced either by adding
                 in a valid product as a seed or by introducing
                 additional mutation and replacement operators that use
                 an SAT solver. In this article, we instead enhance the
                 search in two ways: by providing a novel representation
                 and by optimizing first on the number of constraints
                 that hold and only then on the other objectives. In the
                 evaluation, we also used feature models with realistic
                 attributes, in contrast to previous work that used
                 randomly generated attribute values. The results of
                 experiments were promising, with the proposed (SIP)
                 method returning valid products with six published
                 feature models and a randomly generated feature model
                 with 10,000 features. For the model with 10,000
                 features, the search took only a few minutes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cai:2016:DUD,
  author =       "Haipeng Cai and Raul Santelices and Douglas Thain",
  title =        "{DiaPro}: Unifying Dynamic Impact Analyses for
                 Improved and Variable Cost-Effectiveness",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "18:1--18:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2894751",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Impact analysis not only assists developers with
                 change planning and management, but also facilitates a
                 range of other client analyses, such as testing and
                 debugging. In particular, for developers working in the
                 context of specific program executions, dynamic impact
                 analysis is usually more desirable than static
                 approaches, as it produces more manageable and relevant
                 results with respect to those concrete executions.
                 However, existing techniques for this analysis mostly
                 lie on two extremes: either fast, but too imprecise, or
                 more precise, yet overly expensive. In practice, both
                 more cost-effective techniques and variable
                 cost-effectiveness trade-offs are in demand to fit a
                 variety of usage scenarios and budgets of impact
                 analysis. This article aims to fill the gap between
                 these two extremes with an array of cost-effective
                 analyses and, more broadly, to explore the cost and
                 effectiveness dimensions in the design space of impact
                 analysis. We present the development and evaluation of
                 D iaPro, a framework that unifies a series of impact
                 analyses, including three new hybrid techniques that
                 combine static and dynamic analyses. Harnessing both
                 static dependencies and multiple forms of dynamic data
                 including method-execution events, statement coverage,
                 and dynamic points-to sets, DiaPro prunes
                 false-positive impacts with varying strength for
                 variant effectiveness and overheads. The framework also
                 facilitates an in-depth examination of the effects of
                 various program information on the cost-effectiveness
                 of impact analysis. We applied D iaPro to ten Java
                 applications in diverse scales and domains, evaluating
                 it thoroughly on both arbitrary and repository-based
                 queries from those applications. We show that the three
                 new analyses are all significantly more effective than
                 existing alternatives while remaining efficient, and
                 the DiaPro framework, as a whole, provides flexible
                 cost-effectiveness choices for impact analysis with the
                 best options for variable needs and budgets. Our study
                 results also suggest that hybrid techniques tend to be
                 much more cost-effective than purely dynamic
                 approaches, in general, and that statement coverage has
                 mostly stronger effects than dynamic points-to sets on
                 the cost-effectiveness of dynamic impact analysis,
                 while static dependencies have even stronger effects
                 than both forms of dynamic data.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Anand:2016:SMA,
  author =       "Kapil Anand and Khaled Elwazeer and Aparna Kotha and
                 Matthew Smithson and Rajeev Barua and Angelos
                 Keromytis",
  title =        "A Stack Memory Abstraction and Symbolic Analysis
                 Framework for Executables",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "2",
  pages =        "19:1--19:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2897511",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon May 16 16:22:08 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article makes three contributions regarding
                 reverse-engineering of executables. First, techniques
                 are presented for recovering a precise and correct
                 stack-memory model in executables while addressing
                 executable-specific challenges such as indirect control
                 transfers. Next, the enhanced memory model is employed
                 to define a novel symbolic analysis framework for
                 executables that can perform the same types of program
                 analyses as source-level tools. Third, a demand-driven
                 framework is presented to enhance the scalability of
                 the symbolic analysis framework. Existing symbolic
                 analysis frameworks for executables fail to
                 simultaneously maintain the properties of correct
                 representation, a precise stack-memory model, and
                 scalability. Furthermore, they ignore memory-allocated
                 variables when defining symbolic analysis mechanisms.
                 Our methods do not use symbolic, relocation or debug
                 information, which are usually absent in deployed
                 binaries. We describe our framework, highlighting the
                 novel intellectual contributions of our approach and
                 demonstrating its efficacy and robustness. Our
                 techniques improve the precision of existing
                 stack-memory models by 25\%, enhance scalability of our
                 basic symbolic analysis mechanism by $ 10 \times $, and
                 successfully uncovers five previously undiscovered
                 information-flow vulnerabilities in several widely used
                 programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Baki:2016:MSL,
  author =       "Islem Baki and Houari Sahraoui",
  title =        "Multi-Step Learning and Adaptive Search for Learning
                 Complex Model Transformations from Examples",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "20:1--20:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2904904",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model-driven engineering promotes models as main
                 development artifacts. As several models may be
                 manipulated during the software-development life cycle,
                 model transformations ensure their consistency by
                 automating model generation and update tasks. However,
                 writing model transformations requires much knowledge
                 and effort that detract from their benefits. To address
                 this issue, Model Transformation by Example (MTBE) aims
                 to learn transformation programs from source and target
                 model pairs supplied as examples. In this article, we
                 tackle the fundamental issues that prevent the existing
                 MTBE approaches from efficiently solving the problem of
                 learning model transformations. We show that, when
                 considering complex transformations, the search space
                 is too large to be explored by naive search techniques.
                 We propose an MTBE process to learn complex model
                 transformations by considering three common
                 requirements: element context and state dependencies
                 and complex value derivation. Our process relies on two
                 strategies to reduce the size of the search space and
                 to better explore it, namely, multi-step learning and
                 adaptive search. We experimentally evaluate our
                 approach on seven model transformation problems. The
                 learned transformation programs are able to produce
                 perfect target models in three transformation cases,
                 whereas precision and recall values larger than 90\%
                 are recorded for the four remaining cases.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{He:2016:LWA,
  author =       "Fei He and Xiaowei Gao and Miaofei Wang and Bow-Yaw
                 Wang and Lijun Zhang",
  title =        "Learning Weighted Assumptions for Compositional
                 Verification of {Markov} Decision Processes",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "21:1--21:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2907943",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Probabilistic models are widely deployed in various
                 systems. To ensure their correctness, verification
                 techniques have been developed to analyze probabilistic
                 systems. We propose the first sound and complete
                 learning-based compositional verification technique for
                 probabilistic safety properties on concurrent systems
                 where each component is an Markov decision process.
                 Different from previous works, weighted assumptions are
                 introduced to attain completeness of our framework.
                 Since weighted assumptions can be implicitly
                 represented by multiterminal binary decision diagrams
                 (MTBDDs), we give an {$>$ i$<$L$>$}/{i$<$}*-based
                 learning algorithm for MTBDDs to infer weighted
                 assumptions. Experimental results suggest promising
                 outlooks for our compositional technique.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bhatia:2016:MPG,
  author =       "Jaspreet Bhatia and Travis D. Breaux and Florian
                 Schaub",
  title =        "Mining Privacy Goals from Privacy Policies Using
                 Hybridized Task Recomposition",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "22:1--22:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2907942",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Privacy policies describe high-level goals for
                 corporate data practices; regulators require industries
                 to make available conspicuous, accurate privacy
                 policies to their customers. Consequently, software
                 requirements must conform to those privacy policies. To
                 help stakeholders extract privacy goals from policies,
                 we introduce a semiautomated framework that combines
                 crowdworker annotations, natural language typed
                 dependency parses, and a reusable lexicon to improve
                 goal-extraction coverage, precision, and recall. The
                 framework evaluation consists of a five-policy corpus
                 governing web and mobile information systems, yielding
                 an average precision of 0.73 and recall of 0.83. The
                 results show that no single framework element alone is
                 sufficient to extract goals; however, the overall
                 framework compensates for elemental limitations. Human
                 annotators are highly adaptive at discovering
                 annotations in new texts, but those annotations can be
                 inconsistent and incomplete; dependency parsers lack
                 sophisticated, tacit knowledge, but they can perform
                 exhaustive text search for prospective requirements
                 indicators; and while the lexicon may never completely
                 saturate, the lexicon terms can be reliably used to
                 improve recall. Lexical reuse reduces false negatives
                 by 41\%, increasing the average recall to 0.85. Last,
                 crowd workers were able to identify and remove false
                 positives by around 80\%, which improves average
                 precision to 0.93.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ouni:2016:MCC,
  author =       "Ali Ouni and Marouane Kessentini and Houari Sahraoui
                 and Katsuro Inoue and Kalyanmoy Deb",
  title =        "Multi-Criteria Code Refactoring Using Search-Based
                 Software Engineering: an Industrial Case Study",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "23:1--23:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2932631",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "One of the most widely used techniques to improve the
                 quality of existing software systems is refactoring-the
                 process of improving the design of existing code by
                 changing its internal structure without altering its
                 external behavior. While it is important to suggest
                 refactorings that improve the quality and structure of
                 the system, many other criteria are also important to
                 consider, such as reducing the number of code changes,
                 preserving the semantics of the software design and not
                 only its behavior, and maintaining consistency with the
                 previously applied refactorings. In this article, we
                 propose a multi-objective search-based approach for
                 automating the recommendation of refactorings. The
                 process aims at finding the optimal sequence of
                 refactorings that (i) improves the quality by
                 minimizing the number of design defects, (ii) minimizes
                 code changes required to fix those defects, (iii)
                 preserves design semantics, and (iv) maximizes the
                 consistency with the previously code changes. We
                 evaluated the efficiency of our approach using a
                 benchmark of six open-source systems, 11 different
                 types of refactorings (move method, move field, pull up
                 method, pull up field, push down method, push down
                 field, inline class, move class, extract class, extract
                 method, and extract interface) and six commonly
                 occurring design defect types (blob, spaghetti code,
                 functional decomposition, data class, shotgun surgery,
                 and feature envy) through an empirical study conducted
                 with experts. In addition, we performed an industrial
                 validation of our technique, with 10 software
                 engineers, on a large project provided by our
                 industrial partner. We found that the proposed
                 refactorings succeed in preserving the design coherence
                 of the code, with an acceptable level of code change
                 score while reusing knowledge from recorded
                 refactorings applied in the past to similar contexts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Candela:2016:UCC,
  author =       "Ivan Candela and Gabriele Bavota and Barbara Russo and
                 Rocco Oliveto",
  title =        "Using Cohesion and Coupling for Software
                 Remodularization: Is It Enough?",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "24:1--24:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2928268",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Refactoring and, in particular, remodularization
                 operations can be performed to repair the design of a
                 software system and remove the erosion caused by
                 software evolution. Various approaches have been
                 proposed to support developers during the
                 remodularization of a software system. Most of these
                 approaches are based on the underlying assumption that
                 developers pursue an optimal balance between cohesion
                 and coupling when modularizing the classes of their
                 systems. Thus, a remodularization recommender proposes
                 a solution that implicitly provides a (near) optimal
                 balance between such quality attributes. However, there
                 is still no empirical evidence that such a balance is
                 the desideratum by developers. This article aims at
                 analyzing both objectively and subjectively the
                 aforementioned phenomenon. Specifically, we present the
                 results of (1) a large study analyzing the
                 modularization quality, in terms of package cohesion
                 and coupling, of 100 open-source systems, and (2) a
                 survey conducted with 29 developers aimed at
                 understanding the driving factors they consider when
                 performing modularization tasks. The results achieved
                 have been used to distill a set of lessons learned that
                 might be considered to design more effective
                 remodularization recommenders.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gay:2016:EPM,
  author =       "Gregory Gay and Ajitha Rajan and Matt Staats and
                 Michael Whalen and Mats P. E. Heimdahl",
  title =        "The Effect of Program and Model Structure on the
                 Effectiveness of {MC\slash DC} Test Adequacy Coverage",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "25:1--25:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2934672",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Test adequacy metrics defined over the structure of a
                 program, such as Modified Condition and Decision
                 Coverage (MC/DC), are used to assess testing efforts.
                 However, MC/DC can be ``cheated'' by restructuring a
                 program to make it easier to achieve the desired
                 coverage. This is concerning, given the importance of
                 MC/DC in assessing the adequacy of test suites for
                 critical systems domains. In this work, we have
                 explored the impact of implementation structure on the
                 efficacy of test suites satisfying the MC/DC criterion
                 using four real-world avionics systems. Our results
                 demonstrate that test suites achieving MC/DC over
                 implementations with structurally complex Boolean
                 expressions are generally larger and more effective
                 than test suites achieving MC/DC over functionally
                 equivalent, but structurally simpler, implementations.
                 Additionally, we found that test suites generated over
                 simpler implementations achieve significantly lower
                 MC/DC and fault-finding effectiveness when applied to
                 complex implementations, whereas test suites generated
                 over the complex implementation still achieve high
                 MC/DC and attain high fault finding over the simpler
                 implementation. By measuring MC/DC over simple
                 implementations, we can significantly reduce the cost
                 of testing, but in doing so, we also reduce the
                 effectiveness of the testing process. Thus, developers
                 have an economic incentive to ``cheat'' the MC/DC
                 criterion, but this cheating leads to negative
                 consequences. Accordingly, we recommend that
                 organizations require MC/DC over a structurally complex
                 implementation for testing purposes to avoid these
                 consequences.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Czekster:2016:SPA,
  author =       "Ricardo M. Czekster and Paulo Fernandes and Lucelene
                 Lopes and Afonso Sales and Alan R. Santos and Thais
                 Webber",
  title =        "Stochastic Performance Analysis of Global Software
                 Development Teams",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "26:1--26:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2955093",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Measuring productivity in globally distributed
                 projects is crucial to improve team performance. These
                 measures often display information on whether a given
                 project is moving forward or starts to demonstrate
                 undesired behaviors. In this paper we are interested in
                 showing how analytical models could deliver insights
                 for the behavior of specific distributed software
                 collaboration projects. We present a model for
                 distributed projects using stochastic automata networks
                 (SAN) formalism to estimate, for instance, the required
                 level of coordination for specific project
                 configurations. We focus our attention on the level of
                 interaction among project participants and its close
                 relation with team's productivity. The models are
                 parameterized for different scenarios and solved using
                 numerical methods to obtain exact solutions. We vary
                 the team's expertise and support levels to measure the
                 impact on the overall project performance. As results,
                 we present our derived productivity index for all
                 scenarios and we state implications found in order to
                 analyze popular preconceptions in GSD area, confirming
                 some, and refusing others. Finally, we foresee ways to
                 extend the models to represent more intricate behaviors
                 and communication patterns that are usually present in
                 globally distributed software projects.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2016:HPP,
  author =       "Chunbai Yang and Shangru Wu and W. K. Chan",
  title =        "Hierarchical Program Paths",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "3",
  pages =        "27:1--27:??",
  month =        aug,
  year =         "2016",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2963094",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Aug 23 17:00:23 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Complete dynamic control flow is a fundamental kind of
                 execution profile about program executions with a wide
                 range of applications. Tracing the dynamic control flow
                 of program executions for a brief period easily
                 generates a trace consisting of billions of control
                 flow events. The number of events in such a trace is
                 large, making both path tracing and path querying to
                 incur significant slowdowns. A major class of path
                 tracing techniques is to design novel trace
                 representations that can be generated efficiently, and
                 encode the inputted sequences of such events so that
                 the inputted sequences are still derivable from the
                 encoded and smaller representations. The control flow
                 semantics in such representations have, however, become
                 obscure, which makes implementing path queries on such
                 a representation inefficient and the design of such
                 queries complicated. We propose a novel two-phase path
                 tracing framework- Hierarchical Program Path (HPP)-to
                 model the complete dynamic control flow of an arbitrary
                 number of executions of a program. In Phase 1, HPP
                 monitors each execution, and efficiently generates a
                 stream of events, namely HPPTree, representing a novel
                 tree-based representation of control flow for each
                 thread of control in the execution. In Phase 2, given a
                 set of such event streams, HPP identifies all the
                 equivalent instances of the same exercised
                 interprocedural path in all the corresponding HPPTree
                 instances, and represents each such equivalent set of
                 paths with a single subgraph, resulting in our
                 compositional graph-based trace representation, namely,
                 HPPDAG. Thus, an HPPDAG instance has the potential to
                 be significantly smaller in size than the corresponding
                 HPPTree instances, and still completely preserves the
                 control flow semantics of the traced executions.
                 Control flow queries over all the traced executions can
                 also be directly performed on the single HPPDAG
                 instance instead of separately processing the trace
                 representation of each execution followed by
                 aggregating their results. We validate HPP using the
                 SPLASH2 and SPECint 2006 benchmarks. Compared to the
                 existing technique, named BLPT (Ball-Larus-based Path
                 Tracing), HPP generates significantly smaller trace
                 representations and incurs fewer slowdowns to the
                 native executions in online tracing of Phase 1. The
                 HPPDAG instances generated in Phase 2 are significantly
                 smaller than their corresponding BLPT and HPPTree
                 traces. We show that HPPDAG supports efficient
                 backtrace querying, which is a representative path
                 query based on complete control flow trace. Finally, we
                 illustrate the ease of use of HPPDAG by building a
                 novel and highly efficient path profiling technique to
                 demonstrate the applicability of HPPDAG.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Polyvyanyy:2017:IDP,
  author =       "Artem Polyvyanyy and Wil M. P. {Van Der Aalst} and
                 Arthur H. M. Ter Hofstede and Moe T. Wynn",
  title =        "Impact-Driven Process Model Repair",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "4",
  pages =        "28:1--28:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2980764",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The abundance of event data in today's information
                 systems makes it possible to ``confront'' process
                 models with the actual observed behavior. Process
                 mining techniques use event logs to discover process
                 models that describe the observed behavior, and to
                 check conformance of process models by diagnosing
                 deviations between models and reality. In many
                 situations, it is desirable to mediate between a
                 preexisting model and observed behavior. Hence, we
                 would like to repair the model while improving the
                 correspondence between model and log as much as
                 possible. The approach presented in this article
                 assigns predefined costs to repair actions (allowing
                 inserting or skipping of activities). Given a maximum
                 degree of change, we search for models that are optimal
                 in terms of fitness-that is, the fraction of behavior
                 in the log not possible according to the model is
                 minimized. To compute fitness, we need to align the
                 model and log, which can be time consuming. Hence,
                 finding an optimal repair may be intractable. We
                 propose different alternative approaches to speed up
                 repair. The number of alignment computations can be
                 reduced dramatically while still returning near-optimal
                 repairs. The different approaches have been implemented
                 using the process mining framework ProM and evaluated
                 using real-life logs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Azad:2017:GAC,
  author =       "Shams Azad and Peter C. Rigby and Latifa Guerrouj",
  title =        "Generating {API} Call Rules from Version History and
                 {Stack Overflow} Posts",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "4",
  pages =        "29:1--29:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2990497",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Researchers have shown that related functions can be
                 mined from groupings of functions found in the version
                 history of a system. Our first contribution is to
                 expand this approach to a community of applications and
                 set of similar applications. Android developers use a
                 set of application programming interface (API) calls
                 when creating apps. These API calls are used in similar
                 ways across multiple applications. By clustering
                 co-changing API calls used by 230 Android apps across
                 12k versions, we are able to predict the API calls that
                 individual app developers will use with an average
                 precision of 75\% and recall of 22\%. When we make
                 predictions from the same category of app, such as
                 Finance, we attain precision and recall of 81\% and
                 28\%, respectively. Our second contribution can be
                 characterized as ``programmers who discussed these
                 functions were also interested in these functions.''
                 Informal discussions on Stack Overflow provide a rich
                 source of information about related API calls as
                 developers provide solutions to common problems. By
                 grouping API calls contained in each positively voted
                 answer posts, we are able to create rules that predict
                 the calls that app developers will use in their own
                 apps with an average precision of 66\% and recall of
                 13\%. For comparison purposes, we developed a baseline
                 by clustering co-changing API calls for each individual
                 app and generated association rules from them. The
                 baseline predicts API calls used by app developers with
                 a precision and recall of 36\% and 23\%,
                 respectively.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Palepu:2017:DDS,
  author =       "Vijay Krishna Palepu and Guoqing Xu and James A.
                 Jones",
  title =        "Dynamic Dependence Summaries",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "4",
  pages =        "30:1--30:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/2968444",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software engineers construct modern-day software
                 applications by building on existing software libraries
                 and components that they necessarily do not author
                 themselves. Thus, contemporary software applications
                 rely heavily on existing standard and third-party
                 libraries for their execution and behavior. As such,
                 effective runtime analysis of such a software
                 application's behavior is met with new challenges. To
                 perform dynamic analysis of a software application, all
                 transitively dependent external libraries must also be
                 monitored and analyzed at each layer of the software
                 application's call stack. However, monitoring and
                 analyzing large and often numerous external libraries
                 may prove to be prohibitively expensive. Moreover, an
                 overabundance of library-level analyses may obfuscate
                 the details of the actual software application's
                 dynamic behavior. In other words, the extensive use of
                 existing libraries by a software application renders
                 the results of its dynamic analysis both expensive to
                 compute and difficult to understand. We model software
                 component behavior as dynamically observed data- and
                 control dependencies between inputs and outputs of a
                 software component. Such data- and control dependencies
                 are monitored at a fine-grain instruction-level and are
                 collected as dynamic execution traces for software
                 runs. As an approach to address the complexities and
                 expenses associated with analyzing dynamically
                 observable behavior of software components, we
                 summarize and reuse the data- and control dependencies
                 between the inputs and outputs of software components.
                 Dynamically monitored data- and control dependencies,
                 between the inputs and outputs of software components,
                 upon summarization are called dynamic dependence
                 summaries. Software components, equipped with dynamic
                 dependence summaries, afford the omission of their
                 exhaustive runtime analysis. Nonetheless, the reuse of
                 dependence summaries would necessitate the abstraction
                 of any concrete runtime information enclosed within the
                 summary, thus potentially causing a loss in the
                 information modeled by the dependence summary.
                 Therefore, benefits to the efficiency of dynamic
                 analyses that use such summarization may be afforded
                 with losses of accuracy. As such, we evaluate the
                 potential accuracy loss and the potential performance
                 gain with the use of dynamic dependence summaries. Our
                 results show, on average, a 13$ \times $ speedup with
                 the use of dynamic dependence summaries, with an
                 accuracy of 90\% in a real-world software engineering
                 task.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DeLara:2017:PTM,
  author =       "Juan {De Lara} and Esther Guerra",
  title =        "A Posteriori Typing for Model-Driven Engineering:
                 Concepts, Analysis, and Applications",
  journal =      j-TOSEM,
  volume =       "25",
  number =       "4",
  pages =        "31:1--31:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3063384",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model-Driven Engineering (MDE) is founded on the
                 ability to create and process models conforming to a
                 meta-model. In this context, classes in a meta-model
                 are used in two ways: as templates to create objects
                 and as (static) classifiers for them. These two aspects
                 are inherently tied in most meta-modelling approaches,
                 which results in unnecessarily rigid systems and
                 hinders reusability of MDE artefacts. In this work, we
                 discuss the benefits of decoupling object creation from
                 typing in MDE. Thus, we rely on standard mechanisms for
                 object creation, and propose a posteriori typing as a
                 means to retype objects and enable multiple, partial,
                 dynamic typings. This approach enhances flexibility;
                 permits unanticipated reuse, as model management
                 operations defined for a meta-model can be reused with
                 other models once they get reclassified; and enables
                 bidirectional model transformation by reclassification.
                 In particular, we propose two mechanisms to realise
                 model retyping and show their underlying theory and
                 analysis methods. We show the feasibility of the
                 approach by an implementation atop our meta-modelling
                 tool M etaDepth and present several applications of
                 retypings (transformations, reuse, and dynamicity).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DiNardo:2017:AFD,
  author =       "Daniel {Di Nardo} and Fabrizio Pastore and Lionel
                 Briand",
  title =        "Augmenting Field Data for Testing Systems Subject to
                 Incremental Requirements Changes",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3053430",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "When testing data processing systems, software
                 engineers often use real-world data to perform
                 system-level testing. However, in the presence of new
                 data requirements, software engineers may no longer
                 benefit from having real-world data with which to
                 perform testing. Typically, new test inputs complying
                 with the new requirements have to be manually written.
                 We propose an automated model-based approach that
                 combines data modelling and constraint solving to
                 modify existing field data to generate test inputs for
                 testing new data requirements. The approach scales in
                 the presence of complex and structured data, thanks to
                 both the reuse of existing field data and the adoption
                 of an innovative input generation algorithm based on
                 slicing the model into parts. We validated the
                 scalability and effectiveness of the proposed approach
                 using an industrial case study. The empirical study
                 shows that the approach scales in the presence of large
                 amounts of structured and complex data. The approach
                 can produce, within a reasonable time, test input data
                 that is over ten times larger in size than the data
                 generated with constraint solving only. We also
                 demonstrate that the generated test inputs achieve more
                 code coverage than the test cases implemented by
                 experienced software engineers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sadeghi:2017:ECA,
  author =       "Alireza Sadeghi and Naeem Esfahani and Sam Malek",
  title =        "Ensuring the Consistency of Adaptation through Inter-
                 and Intra-Component Dependency Analysis",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3063385",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Dynamic adaptation should not leave a software system
                 in an inconsistent state, as it could lead to failure.
                 Prior research has used inter-component dependency
                 models of a system to determine a safe interval for the
                 adaptation of its components, where the most important
                 tradeoff is between disruption in the operations of the
                 system and reachability of safe intervals. This article
                 presents Savasana, which automatically analyzes a
                 software system's code to extract both inter- and
                 intra-component dependencies. In this way, Savasana is
                 able to obtain more fine-grained models compared to
                 previous approaches. Savasana then uses the detailed
                 models to find safe adaptation intervals that cannot be
                 determined using techniques from prior research. This
                 allows Savasana to achieve a better tradeoff between
                 disruption and reachability. The article demonstrates
                 how Savasana infers safe adaptation intervals for
                 components of a software system under various use cases
                 and conditions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mills:2017:PQQ,
  author =       "Chris Mills and Gabriele Bavota and Sonia Haiduc and
                 Rocco Oliveto and Andrian Marcus and Andrea {De
                 Lucia}",
  title =        "Predicting Query Quality for Applications of Text
                 Retrieval to Software Engineering Tasks",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3078841",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Context: Since the mid-2000s, numerous recommendation
                 systems based on text retrieval (TR) have been proposed
                 to support software engineering (SE) tasks such as
                 concept location, traceability link recovery, code
                 reuse, impact analysis, and so on. The success of
                 TR-based solutions highly depends on the query
                 submitted, which is either formulated by the developer
                 or automatically extracted from software artifacts.
                 Aim: We aim at predicting the quality of queries
                 submitted to TR-based approaches in SE. This can lead
                 to benefits for developers and for the quality of
                 software systems alike. For example, knowing when a
                 query is poorly formulated can save developers the time
                 and frustration of analyzing irrelevant search results.
                 Instead, they could focus on reformulating the query.
                 Also, knowing if an artifact used as a query leads to
                 irrelevant search results may uncover underlying
                 problems in the query artifact itself. Method: We
                 introduce an automatic query quality prediction
                 approach for software artifact retrieval by adapting
                 NL-inspired solutions to their use on software data. We
                 present two applications and evaluations of the
                 approach in the context of concept location and
                 traceability link recovery, where TR has been applied
                 most often in SE. For concept location, we use the
                 approach to determine if the list of retrieved code
                 elements is likely to contain code relevant to a
                 particular change request or not, in which case, the
                 queries are good candidates for reformulation. For
                 traceability link recovery, the queries represent
                 software artifacts. In this case, we use the query
                 quality prediction approach to identify artifacts that
                 are hard to trace to other artifacts and may therefore
                 have a low intrinsic quality for TR-based traceability
                 link recovery. Results: For concept location, the
                 evaluation shows that our approach is able to correctly
                 predict the quality of queries in 82\% of the cases, on
                 average, using very little training data. In the case
                 of traceability recovery, the proposed approach is able
                 to detect hard to trace artifacts in 74\% of the cases,
                 on average. Conclusions: The results of our evaluation
                 on applications for concept location and traceability
                 link recovery indicate that our approach can be used to
                 predict the results of a TR-based approach by assessing
                 the quality of the text query. This can lead to saved
                 effort and time, as well as the identification of
                 software artifacts that may be difficult to trace using
                 TR.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yoo:2017:HCG,
  author =       "Shin Yoo and Xiaoyuan Xie and Fei-Ching Kuo and Tsong
                 Yueh Chen and Mark Harman",
  title =        "Human Competitiveness of Genetic Programming in
                 Spectrum-Based Fault Localisation: Theoretical and
                 Empirical Analysis",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3078840",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We report on the application of Genetic Programming to
                 Software Fault Localisation, a problem in the area of
                 Search-Based Software Engineering (SBSE). We give both
                 empirical and theoretical evidence for the human
                 competitiveness of the evolved fault localisation
                 formul{\ae} under the single fault scenario, compared
                 to those generated by human ingenuity and reported in
                 many papers, published over more than a decade. Though
                 there have been previous human competitive results
                 claimed for SBSE problems, this is the first time that
                 evolved solutions have been formally proved to be human
                 competitive. We further prove that no future human
                 investigation could outperform the evolved solutions.
                 We complement these proofs with an empirical analysis
                 of both human and evolved solutions, which indicates
                 that the evolved solutions are not only theoretically
                 human competitive, but also convey similar practical
                 benefits to human-evolved counterparts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2017:PAG,
  author =       "Robert M. Hierons and Uraz Cengiz T{\"u}rker",
  title =        "Parallel Algorithms for Generating Distinguishing
                 Sequences for Observable Non-deterministic {FSMs}",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "1",
  pages =        "5:1--5:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3051121",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 24 09:31:14 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A distinguishing sequence (DS) for a finite-state
                 machine (FSM) is an input sequence that distinguishes
                 every pair of states of the FSM. There are techniques
                 that generate a test sequence with guaranteed fault
                 detection power, and it has been found that shorter
                 test sequences can be produced if DSs are used. Despite
                 these benefits, however, until recently the only
                 published DS generation algorithms have been for
                 deterministic FSMs. This article develops a massively
                 parallel algorithm, which can be used in Graphics
                 Processing Units (GPUs) Computing, to generate DSs from
                 partial observable non-deterministic FSMs. We also
                 present the results of experiments using randomly
                 generated FSMs and some benchmark FSMs. The results are
                 promising and indicate that the proposed algorithm can
                 derive DSs from partial observable non-deterministic
                 FSMs with 32,000 states in an acceptable amount of
                 time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2017:E,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "2",
  pages =        "6:1--6:??",
  month =        oct,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3136621",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 5 18:22:13 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Scanniello:2017:FFC,
  author =       "Giuseppe Scanniello and Michele Risi and Porfirio
                 Tramontana and Simone Romano",
  title =        "Fixing Faults in {C} and {Java} Source Code:
                 Abbreviated vs. Full-Word Identifier Names",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "2",
  pages =        "6:1--6:??",
  month =        oct,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3104029",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 5 18:22:13 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We carried out a family of controlled experiments to
                 investigate whether the use of abbreviated identifier
                 names, with respect to full-word identifier names,
                 affects fault fixing in C and Java source code. This
                 family consists of an original (or baseline) controlled
                 experiment and three replications. We involved 100
                 participants with different backgrounds and experiences
                 in total. Overall results suggested that there is no
                 difference in terms of effort, effectiveness, and
                 efficiency to fix faults, when source code contains
                 either only abbreviated or only full-word identifier
                 names. We also conducted a qualitative study to
                 understand the values, beliefs, and assumptions that
                 inform and shape fault fixing when identifier names are
                 either abbreviated or full-word. We involved in this
                 qualitative study six professional developers with 1--3
                 years of work experience. A number of insights emerged
                 from this qualitative study and can be considered a
                 useful complement to the quantitative results from our
                 family of experiments. One of the most interesting
                 insights is that developers, when working on source
                 code with abbreviated identifier names, adopt a more
                 methodical approach to identify and fix faults by
                 extending their focus point and only in a few cases do
                 they expand abbreviated identifiers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Baresi:2017:LBA,
  author =       "Luciano Baresi and Angelo Morzenti and Alfredo Motta
                 and Mohammad Mehdi Pourhashem K. and Matteo Rossi",
  title =        "A Logic-Based Approach for the Verification of {UML}
                 Timed Models",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "2",
  pages =        "7:1--7:??",
  month =        oct,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3106411",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 5 18:22:13 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "This article presents a novel technique to formally
                 verify models of real-time systems captured through a
                 set of heterogeneous UML diagrams. The technique is
                 based on the following key elements: (i) a subset of
                 Unified Modeling Language (UML) diagrams, called
                 Coretto UML (C-UML), which allows designers to describe
                 the components of the system and their behavior through
                 several kinds of diagrams (e.g., state machine
                 diagrams, sequence diagrams, activity diagrams,
                 interaction overview diagrams), and stereotypes taken
                 from the UML Profile for Modeling and Analysis of
                 Real-Time and Embedded Systems; (ii) a formal semantics
                 of C-UML diagrams, defined through formulae of the
                 metric temporal logic Tempo Reale ImplicitO (TRIO); and
                 (iii) a tool, called Corretto, which implements the
                 aforementioned semantics and allows users to carry out
                 formal verification tasks on modeled systems. We
                 validate the feasibility of our approach through a set
                 of different case studies, taken from both the academic
                 and the industrial domain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Karanikolas:2017:EEI,
  author =       "Chris Karanikolas and Grigoris Dimitroulakos and
                 Konstantinos Masselos",
  title =        "Early Evaluation of Implementation Alternatives of
                 Composite Data Structures Toward Maintainability",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "2",
  pages =        "8:1--8:??",
  month =        oct,
  year =         "2017",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3132731",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 5 18:22:13 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tosem/;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Selecting between different design options is a
                 crucial decision for object-oriented software
                 developers that affects code quality characteristics.
                 Conventionally developers use their experience to make
                 such decisions, which leads to suboptimal results
                 regarding code quality. In this article, a formal model
                 for providing early estimates of quality metrics of
                 object-oriented software implementation alternatives is
                 proposed. The model supports software developers in
                 making fast decisions in a systematic way early during
                 the design phase to achieve improved code
                 characteristics. The approach employs a comparison
                 model related to the application of the Visitor design
                 pattern and inheritance-based implementation on
                 structures following the Composite design pattern. The
                 model captures maintainability as a metric of software
                 quality and provides precise assessments of the quality
                 of each implementation alternative. Furthermore, the
                 model introduces the structural maintenance cost metric
                 based on which the progressive analysis of the
                 maintenance process is introduced. The proposed
                 approach has been applied to several test cases for
                 different relevant quality metrics. The results prove
                 that the proposed model delivers accurate estimations.
                 Thus, the proposed methodology can be used for
                 comparing different implementation alternatives against
                 various measures and quality factors before code
                 development, leading to reduced effort and cost for
                 software maintenance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Attie:2018:GLD,
  author =       "Paul C. Attie and Saddek Bensalem and Marius Bozga and
                 Mohamad Jaber and Joseph Sifakis and Fadi A. Zaraket",
  title =        "Global and Local Deadlock Freedom in {BIP}",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "3",
  pages =        "9:1--9:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3152910",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jan 22 17:44:40 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present a criterion for checking local and global
                 deadlock freedom of finite state systems expressed in
                 BIP: a component-based framework for constructing
                 complex distributed systems. Our criterion is evaluated
                 by model-checking a set of subsystems of the overall
                 large system. If satisfied in small subsystems, it
                 implies deadlock-freedom of the overall system. If not
                 satisfied, then we re-evaluate over larger subsystems,
                 which improves the accuracy of the check. When the
                 subsystem being checked becomes the entire system, our
                 criterion becomes complete for deadlock-freedom. Hence
                 our criterion only fails to decide deadlock freedom
                 because of computational limitations: state-space
                 explosion sets in when the subsystems become too large.
                 Our method thus combines the possibility of fast
                 response together with theoretical completeness. Other
                 criteria for deadlock freedom, in contrast, are
                 incomplete in principle, and so may fail to decide
                 deadlock freedom even if unlimited computational
                 resources are available. Also, our criterion certifies
                 freedom from local deadlock, in which a subsystem is
                 deadlocked while the rest of the system executes. Other
                 criteria only certify freedom from global deadlock. We
                 present experimental results for dining philosophers
                 and for a multi-token-based resource allocation system,
                 which subsumes several data arbiters and schedulers,
                 including Milner's token-based scheduler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Abal:2018:VBH,
  author =       "Iago Abal and Jean Melo and Stefan Stanciulescu and
                 Claus Brabrand and M{\'a}rcio Ribeiro and Andrzej
                 Wasowski",
  title =        "Variability Bugs in Highly Configurable Systems: a
                 Qualitative Analysis",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "3",
  pages =        "10:1--10:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3149119",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jan 22 17:44:40 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Variability-sensitive verification pursues effective
                 analysis of the exponentially many variants of a
                 program family. Several variability-aware techniques
                 have been proposed, but researchers still lack examples
                 of concrete bugs induced by variability, occurring in
                 real large-scale systems. A collection of real world
                 bugs is needed to evaluate tool implementations of
                 variability-sensitive analyses by testing them on real
                 bugs. We present a qualitative study of 98 diverse
                 variability bugs (i.e., bugs that occur in some
                 variants and not in others) collected from bug-fixing
                 commits in the Linux, Apache, BusyBox, and Marlin
                 repositories. We analyze each of the bugs, and record
                 the results in a database. For each bug, we create a
                 self-contained simplified version and a simplified
                 patch, in order to help researchers who are not experts
                 on these subject studies to understand them, so that
                 they can use these bugs for evaluation of their tools.
                 In addition, we provide single-function versions of the
                 bugs, which are useful for evaluating intra-procedural
                 analyses. A web-based user interface for the database
                 allows to conveniently browse and visualize the
                 collection of bugs. Our study provides insights into
                 the nature and occurrence of variability bugs in four
                 highly-configurable systems implemented in C/C++, and
                 shows in what ways variability hinders comprehension
                 and the uncovering of software bugs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Garcia:2018:LOR,
  author =       "Joshua Garcia and Mahmoud Hammad and Sam Malek",
  title =        "Lightweight, Obfuscation-Resilient Detection and
                 Family Identification of {Android} Malware",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "3",
  pages =        "11:1--11:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3162625",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jan 22 17:44:40 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The number of malicious Android apps is increasing
                 rapidly. Android malware can damage or alter other
                 files or settings, install additional applications, and
                 so on. To determine such behaviors, a security analyst
                 can significantly benefit from identifying the family
                 to which an Android malware belongs rather than only
                 detecting if an app is malicious. Techniques for
                 detecting Android malware, and determining their
                 families, lack the ability to handle certain
                 obfuscations that aim to thwart detection. Moreover,
                 some prior techniques face scalability issues,
                 preventing them from detecting malware in a timely
                 manner. To address these challenges, we present a novel
                 machine-learning-based Android malware detection and
                 family identification approach, RevealDroid, that
                 operates without the need to perform complex program
                 analyses or to extract large sets of features.
                 Specifically, our selected features leverage
                 categorized Android API usage, reflection-based
                 features, and features from native binaries of apps. We
                 assess RevealDroid for accuracy, efficiency, and
                 obfuscation resilience using a large dataset consisting
                 of more than 54,000 malicious and benign apps. Our
                 experiments show that RevealDroid achieves an accuracy
                 of 98\% in detection of malware and an accuracy of 95\%
                 in determination of their families. We further
                 demonstrate RevealDroid's superiority against
                 state-of-the-art approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nguyen:2018:UCM,
  author =       "Khanh Nguyen and Kai Wang and Yingyi Bu and Lu Fang
                 and Guoqing Xu",
  title =        "Understanding and Combating Memory Bloat in Managed
                 Data-Intensive Systems",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "4",
  pages =        "12:1--12:41",
  month =        feb,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3162626",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:39 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The past decade has witnessed increasing demands on
                 data-driven business intelligence that led to the
                 proliferation of data-intensive applications. A managed
                 object-oriented programming language such as Java is
                 often the developer's choice for implementing such
                 applications, due to its quick development cycle and
                 rich suite of libraries and frameworks. While the use
                 of such languages makes programming easier, their
                 automated memory management comes at a cost. When the
                 managed runtime meets large volumes of input data,
                 memory bloat is significantly magnified and becomes a
                 scalability-prohibiting bottleneck. This article first
                 studies, analytically and empirically, the impact of
                 bloat on the performance and scalability of
                 large-scale, real-world data-intensive systems. To
                 combat bloat, we design a novel compiler framework,
                 called F acade, that can generate highly efficient data
                 manipulation code by automatically transforming the
                 data path of an existing data-intensive application.
                 The key treatment is that in the generated code, the
                 number of runtime heap objects created for data classes
                 in each thread is (almost) statically bounded, leading
                 to significantly reduced memory management cost and
                 improved scalability. We have implemented Facade and
                 used it to transform seven common applications on three
                 real-world, already well-optimized data processing
                 frameworks: GraphChi, Hyracks, and GPS. Our
                 experimental results are very positive: the generated
                 programs have (1) achieved a 3\% to 48\% execution time
                 reduction and an up to 88$ \times $ GC time reduction,
                 (2) consumed up to 50\% less memory, and (3) scaled to
                 much larger datasets.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lucia:2018:DBD,
  author =       "Andrea {De Lucia} and Vincenzo Deufemia and Carmine
                 Gravino and Michele Risi",
  title =        "Detecting the Behavior of Design Patterns through
                 Model Checking and Dynamic Analysis",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "4",
  pages =        "13:1--13:??",
  month =        feb,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3176643",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:39 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "We present a method and tool (ePAD) for the detection
                 of design pattern instances in source code. The
                 approach combines static analysis, based on visual
                 language parsing and model checking, and dynamic
                 analysis, based on source code instrumentation. Visual
                 language parsing and static source code analysis
                 identify candidate instances satisfying the structural
                 properties of design patterns. Successively, model
                 checking statically verifies the behavioral aspects of
                 the candidates recovered in the previous phase. We
                 encode the sequence of messages characterizing the
                 correct behaviour of a pattern as Linear Temporal Logic
                 (LTL) formulae and the sequence diagram representing
                 the possible interaction traces among the objects
                 involved in the candidates as Promela specifications.
                 The model checker SPIN verifies that candidates satisfy
                 the LTL formulae. Dynamic analysis is then performed on
                 the obtained candidates by instrumenting the source
                 code and monitoring those instances at runtime through
                 the execution of test cases automatically generated
                 using a search-based approach. The effectiveness of
                 ePAD has been evaluated by detecting instances of 12
                 creational and behavioral patterns from six publicly
                 available systems. The results reveal that ePAD
                 outperforms other approaches by recovering more actual
                 instances. Furthermore, on average ePAD achieves better
                 results in terms of correctness and completeness.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xiang:2018:CSP,
  author =       "Yi Xiang and Yuren Zhou and Zibin Zheng and Miqing
                 Li",
  title =        "Configuring Software Product Lines by Combining
                 Many-Objective Optimization and {SAT} Solvers",
  journal =      j-TOSEM,
  volume =       "26",
  number =       "4",
  pages =        "14:1--14:??",
  month =        feb,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3176644",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:39 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A feature model (FM) is a compact representation of
                 the information of all possible products from software
                 product lines. The optimal feature selection involves
                 the simultaneous optimization of multiple (usually more
                 than three) objectives in a large and highly
                 constrained search space. By combining our previous
                 work on many-objective evolutionary algorithm (i.e.,
                 VaEA) with two different satisfiability (SAT) solvers,
                 this article proposes a new approach named SATVaEA for
                 handling the optimal feature selection problem. In
                 SATVaEA, an FM is simplified with the number of both
                 features and constraints being reduced greatly. We
                 enhance the search of VaEA by using two SAT solvers:
                 one is a stochastic local search--based SAT solver that
                 can quickly repair infeasible configurations, whereas
                 the other is a conflict-driven clause-learning SAT
                 solver that is introduced to generate diversified
                 products. We evaluate SATVaEA on 21 FMs with up to
                 62,482 features, including two models with realistic
                 values for feature attributes. The experimental results
                 are promising, with SATVaEA returning 100\% valid
                 products on almost all FMs. For models with more than
                 10,000 features, the search in SATVaEA takes only a few
                 minutes. Concerning both effectiveness and efficiency,
                 SATVaEA significantly outperforms other
                 state-of-the-art algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2018:Ea,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3205909",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2018:HFW,
  author =       "Yuming Zhou and Yibiao Yang and Hongmin Lu and Lin
                 Chen and Yanhui Li and Yangyang Zhao and Junyan Qian
                 and Baowen Xu",
  title =        "How Far We Have Progressed in the Journey? {An}
                 Examination of Cross-Project Defect Prediction",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3183339",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Background. Recent years have seen an increasing
                 interest in cross-project defect prediction (CPDP),
                 which aims to apply defect prediction models built on
                 source projects to a target project. Currently, a
                 variety of (complex) CPDP models have been proposed
                 with a promising prediction performance. Problem. Most,
                 if not all, of the existing CPDP models are not
                 compared against those simple module size models that
                 are easy to implement and have shown a good performance
                 in defect prediction in the literature. Objective. We
                 aim to investigate how far we have really progressed in
                 the journey by comparing the performance in defect
                 prediction between the existing CPDP models and simple
                 module size models. Method. We first use module size in
                 the target project to build two simple defect
                 prediction models, ManualDown and ManualUp, which do
                 not require any training data from source projects.
                 ManualDown considers a larger module as more
                 defect-prone, while ManualUp considers a smaller module
                 as more defect-prone. Then, we take the following
                 measures to ensure a fair comparison on the performance
                 in defect prediction between the existing CPDP models
                 and the simple module size models: using the same
                 publicly available data sets, using the same
                 performance indicators, and using the prediction
                 performance reported in the original cross-project
                 defect prediction studies. Result. The simple module
                 size models have a prediction performance comparable or
                 even superior to most of the existing CPDP models in
                 the literature, including many newly proposed models.
                 Conclusion. The results caution us that, if the
                 prediction performance is the goal, the real progress
                 in CPDP is not being achieved as it might have been
                 envisaged. We hence recommend that future studies
                 should include ManualDown/ManualUp as the baseline
                 models for comparison when developing new CPDP models
                 to predict defects in a complete target project.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Vidal:2018:ARB,
  author =       "Santiago Vidal and I{\~n}aki Berra and Santiago
                 Zulliani and Claudia Marcos and J. Andr{\'e}s
                 {D{\'\i}az Pace}",
  title =        "Assessing the Refactoring of Brain Methods",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3191314",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Code smells are a popular mechanism for identifying
                 structural design problems in software systems. Several
                 tools have emerged to support the detection of code
                 smells and propose some refactorings. However, existing
                 tools do not guarantee that a smell will be
                 automatically fixed by means of refactorings. This
                 article presents Bandago, an automated approach to fix
                 a specific type of code smell called Brain Method. A
                 Brain Method centralizes the intelligence of a class
                 and manifests itself as a long and complex method that
                 is difficult to understand and maintain by developers.
                 For each Brain Method, Bandago recommends several
                 refactoring solutions to remove the smell using a
                 search strategy based on simulated annealing. Our
                 approach has been evaluated with several open-source
                 Java applications, and the results show that Bandago
                 can automatically fix more than 60\% of Brain Methods.
                 Furthermore, we conducted a survey with 35 industrial
                 developers that showed evidence about the usefulness of
                 the refactorings proposed by Bandago. Also, we compared
                 the performance of the Bandago against that of a
                 third-party refactoring tool.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2018:ESM,
  author =       "Yuanyuan Zhang and Mark Harman and Gabriela Ochoa and
                 Guenther Ruhe and Sjaak Brinkkemper",
  title =        "An Empirical Study of Meta- and Hyper-Heuristic Search
                 for Multi-Objective Release Planning",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3196831",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A variety of meta-heuristic search algorithms have
                 been introduced for optimising software release
                 planning. However, there has been no comprehensive
                 empirical study of different search algorithms across
                 multiple different real-world datasets. In this
                 article, we present an empirical study of global,
                 local, and hybrid meta- and hyper-heuristic
                 search-based algorithms on 10 real-world datasets. We
                 find that the hyper-heuristics are particularly
                 effective. For example, the hyper-heuristic genetic
                 algorithm significantly outperformed the other six
                 approaches (and with high effect size) for solution
                 quality 85\% of the time, and was also faster than all
                 others 70\% of the time. Furthermore, correlation
                 analysis reveals that it scales well as the number of
                 requirements increases.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Emam:2018:IEP,
  author =       "S. S. Emam and J. Miller",
  title =        "Inferring Extended Probabilistic Finite-State
                 Automaton Models from Software Executions",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3196883",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 8 17:20:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Behavioral models are useful tools in understanding
                 how programs work. Although several inference
                 approaches have been introduced to generate extended
                 finite-state automatons from software execution traces,
                 they suffer from accuracy, flexibility, and
                 decidability issues. In this article, we apply a hybrid
                 technique to use both reinforcement learning and
                 stochastic modeling to generate an extended
                 probabilistic finite state automaton from software
                 traces. Our approach-ReHMM (Reinforcement
                 learning-based Hidden Markov Modelling)-is able to
                 address the problems of inflexibility and
                 un-decidability reported in other state-of-the-art
                 approaches. Experimental results indicate that ReHMM
                 outperforms other inference algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2018:FFG,
  author =       "Tao Chen and Ke Li and Rami Bahsoon and Xin Yao",
  title =        "{FEMOSAA}: Feature-Guided and Knee-Driven
                 Multi-Objective Optimization for Self-Adaptive
                 Software",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "2",
  pages =        "5:1--5:??",
  month =        jul,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3204459",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Self-Adaptive Software (SAS) can reconfigure itself to
                 adapt to the changing environment at runtime, aiming to
                 continually optimize conflicted nonfunctional
                 objectives (e.g., response time, energy consumption,
                 throughput, cost, etc.). In this article, we present
                 Feature-guided and knEe-driven Multi-Objective
                 optimization for Self-Adaptive softwAre (FEMOSAA), a
                 novel framework that automatically synergizes the
                 feature model and Multi-Objective Evolutionary
                 Algorithm (MOEA) to optimize SAS at runtime. FEMOSAA
                 operates in two phases: at design time, FEMOSAA
                 automatically transposes the engineers' design of SAS,
                 expressed as a feature model, to fit the MOEA, creating
                 new chromosome representation and reproduction
                 operators. At runtime, FEMOSAA utilizes the feature
                 model as domain knowledge to guide the search and
                 further extend the MOEA, providing a larger chance for
                 finding better solutions. In addition, we have designed
                 a new method to search for the knee solutions, which
                 can achieve a balanced tradeoff. We comprehensively
                 evaluated FEMOSAA on two running SAS: One is a highly
                 complex SAS with various adaptable real-world software
                 under the realistic workload trace; another is a
                 service-oriented SAS that can be dynamically composed
                 from services. In particular, we compared the
                 effectiveness and overhead of FEMOSAA against four of
                 its variants and three other search-based frameworks
                 for SAS under various scenarios, including three
                 commonly applied MOEAs, two workload patterns, and
                 diverse conflicting quality objectives. The results
                 reveal the effectiveness of FEMOSAA and its superiority
                 over the others with high statistical significance and
                 nontrivial effect sizes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Riesco:2018:PII,
  author =       "Adri{\'a}n Riesco and Kazuhiro Ogata",
  title =        "Prove it! {Inferring} Formal Proof Scripts from
                 {CafeOBJ} Proof Scores",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "2",
  pages =        "6:1--6:??",
  month =        jul,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3208951",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "CafeOBJ is a language for writing formal
                 specifications for a wide variety of software and
                 hardware systems and for verifying their properties.
                 CafeOBJ makes it possible to verify properties by using
                 either proof scores, which consists of reducing
                 goal-related terms in user-defined modules, or by using
                 theorem proving. While the former is more flexible, it
                 lacks the formal support to ensure that a property has
                 been really proven. On the other hand, theorem proving
                 might be too strict, since only a predefined set of
                 commands can be applied to the current goal; hence, it
                 hardens the verification of properties. In order to
                 take advantage of the benefits of both techniques, we
                 have extended CafeInMaude, a CafeOBJ interpreter
                 implemented in Maude, with the CafeInMaude Proof
                 Assistant (CiMPA) and the CafeInMaude Proof Generator
                 (CiMPG). CiMPA is a proof assistant for proving
                 inductive properties on CafeOBJ specifications that
                 uses Maude metalevel features to allow programmers to
                 create and manipulate CiMPA proofs. On the other hand,
                 CiMPG provides a minimal set of annotations for
                 identifying proof scores and generating CiMPA scripts
                 for these proof scores. In this article, we present the
                 CiMPA and CiMPG, detailing the behavior of the CiMPA
                 and the algorithm underlying the CiMPG and illustrating
                 the power of the approach by using the QLOCK protocol.
                 Finally, we present some benchmarks that give us
                 confidence in the matureness and usefulness of these
                 tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bohme:2018:SST,
  author =       "Marcel B{\"o}hme",
  title =        "{STADS}: Software Testing as Species Discovery",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jul,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3210309",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A fundamental challenge of software testing is the
                 statistically well-grounded extrapolation from program
                 behaviors observed during testing. For instance, a
                 security researcher who has run the fuzzer for a week
                 has currently no means (1) to estimate the total number
                 of feasible program branches, given that only a
                 fraction has been covered so far; (2) to estimate the
                 additional time required to cover 10\% more branches
                 (or to estimate the coverage achieved in one more day,
                 respectively); or (3) to assess the residual risk that
                 a vulnerability exists when no vulnerability has been
                 discovered. Failing to discover a vulnerability does
                 not mean that none exists-even if the fuzzer was run
                 for a week (or a year). Hence, testing provides no
                 formal correctness guarantees. In this article, I
                 establish an unexpected connection with the otherwise
                 unrelated scientific field of ecology and introduce a
                 statistical framework that models Software Testing and
                 Analysis as Discovery of Species (STADS). For instance,
                 in order to study the species diversity of arthropods
                 in a tropical rain forest, ecologists would first
                 sample a large number of individuals from that forest,
                 determine their species, and extrapolate from the
                 properties observed in the sample to properties of the
                 whole forest. The estimations (1) of the total number
                 of species, (2) of the additional sampling effort
                 required to discover 10\% more species, or (3) of the
                 probability to discover a new species are classical
                 problems in ecology. The STADS framework draws from
                 over three decades of research in ecological
                 biostatistics to address the fundamental extrapolation
                 challenge for automated test generation. Our
                 preliminary empirical study demonstrates a good
                 estimator performance even for a fuzzer with adaptive
                 sampling bias-AFL, a state-of-the-art vulnerability
                 detection tool. The STADS framework provides
                 statistical correctness guarantees with quantifiable
                 accuracy.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zheng:2018:MAI,
  author =       "Yongjie Zheng and Cuong Cu and Richard N. Taylor",
  title =        "Maintaining Architecture-Implementation Conformance to
                 Support Architecture Centrality: From Single System to
                 Product Line Development",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jul,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3229048",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Architecture-centric development addresses the
                 increasing complexity and variability of software
                 systems by focusing on architectural models, which are
                 generally easier to understand and manipulate than
                 source code. It requires a mechanism that can maintain
                 architecture-implementation conformance during
                 architectural development and evolution. The challenge
                 is twofold. There is an abstraction gap between
                 software architecture and implementation, and both may
                 evolve. Existing approaches are deficient in support
                 for both change mapping and product line architecture.
                 This article presents a novel approach named 1.x-way
                 mapping and its extension, 1.x-line mapping to support
                 architecture-implementation mapping in single system
                 development and in product line development,
                 respectively. They specifically address mapping
                 architecture changes to code, maintaining variability
                 conformance between product line architecture and code,
                 and tracing architectural implementation. We built
                 software tools named xMapper and xLineMapper to realize
                 the two approaches, and conducted case studies with two
                 existing open-source systems to evaluate the
                 approaches. The result shows that our approaches are
                 applicable to the implementation of a real software
                 system and are capable of maintaining
                 architecture-implementation conformance during system
                 evolution.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2018:Eb,
  author =       "David S. Rosenblum",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "9:1--9:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3264424",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kuchta:2018:SSE,
  author =       "Tomasz Kuchta and Hristina Palikareva and Cristian
                 Cadar",
  title =        "Shadow Symbolic Execution for Testing Software
                 Patches",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "10:1--10:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3208952",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "While developers are aware of the importance of
                 comprehensively testing patches, the large effort
                 involved in coming up with relevant test cases means
                 that such testing rarely happens in practice.
                 Furthermore, even when test cases are written to cover
                 the patch, they often exercise the same behaviour in
                 the old and the new version of the code. In this
                 article, we present a symbolic execution-based
                 technique that is designed to generate test inputs that
                 cover the new program behaviours introduced by a patch.
                 The technique works by executing both the old and the
                 new version in the same symbolic execution instance,
                 with the old version shadowing the new one. During this
                 combined shadow execution, whenever a branch point is
                 reached where the old and the new version diverge, we
                 generate a test input exercising the divergence and
                 comprehensively test the new behaviours of the new
                 version. We evaluate our technique on the Coreutils
                 patches from the CoREBench suite of regression bugs,
                 and show that it is able to generate test inputs that
                 exercise newly added behaviours and expose some of the
                 regression bugs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Stol:2018:ASE,
  author =       "Klaas-Jan Stol and Brian Fitzgerald",
  title =        "The {ABC} of Software Engineering Research",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "11:1--11:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3241743",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "A variety of research methods and techniques are
                 available to SE researchers, and while several
                 overviews exist, there is consistency neither in the
                 research methods covered nor in the terminology used.
                 Furthermore, research is sometimes critically reviewed
                 for characteristics inherent to the methods. We adopt a
                 taxonomy from the social sciences, termed here the ABC
                 framework for SE research, which offers a holistic view
                 of eight archetypal research strategies. ABC refers to
                 the research goal that strives for generalizability
                 over Actors (A) and precise measurement of their
                 Behavior (B), in a realistic Context (C). The ABC
                 framework uses two dimensions widely considered to be
                 key in research design: the level of obtrusiveness of
                 the research and the generalizability of research
                 findings. We discuss metaphors for each strategy and
                 their inherent limitations and potential strengths. We
                 illustrate these research strategies in two key SE
                 domains, global software engineering and requirements
                 engineering, and apply the framework on a sample of 75
                 articles. Finally, we discuss six ways in which the
                 framework can advance SE research.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sarro:2018:LPB,
  author =       "Federica Sarro and Alessio Petrozziello",
  title =        "Linear Programming as a Baseline for Software Effort
                 Estimation",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "12:1--12:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3234940",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software effort estimation studies still suffer from
                 discordant empirical results (i.e., conclusion
                 instability) mainly due to the lack of rigorous
                 benchmarking methods. So far only one baseline model,
                 namely, Automatically Transformed Linear Model (ATLM),
                 has been proposed yet it has not been extensively
                 assessed. In this article, we propose a novel method
                 based on Linear Programming (dubbed as Linear
                 Programming for Effort Estimation, LP4EE) and carry out
                 a thorough empirical study to evaluate the
                 effectiveness of both LP4EE and ATLM for benchmarking
                 widely used effort estimation techniques. The results
                 of our study confirm the need to benchmark every other
                 proposal against accurate and robust baselines. They
                 also reveal that LP4EE is more accurate than ATLM for
                 17\% of the experiments and more robust than ATLM
                 against different data splits and cross-validation
                 methods for 44\% of the cases. These results suggest
                 that using LP4EE as a baseline can help reduce
                 conclusion instability. We make publicly available an
                 open-source implementation of LP4EE in order to
                 facilitate its adoption in future studies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Troya:2018:SBF,
  author =       "Javier Troya and Sergio Segura and Jose Antonio Parejo
                 and Antonio Ruiz-Cort{\'e}s",
  title =        "Spectrum-Based Fault Localization in Model
                 Transformations",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "13:1--13:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3241744",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Model transformations play a cornerstone role in
                 Model-Driven Engineering (MDE), as they provide the
                 essential mechanisms for manipulating and transforming
                 models. The correctness of software built using MDE
                 techniques greatly relies on the correctness of model
                 transformations. However, it is challenging and error
                 prone to debug them, and the situation gets more
                 critical as the size and complexity of model
                 transformations grow, where manual debugging is no
                 longer possible. Spectrum-Based Fault Localization
                 (SBFL) uses the results of test cases and their
                 corresponding code coverage information to estimate the
                 likelihood of each program component (e.g., statements)
                 of being faulty. In this article we present an approach
                 to apply SBFL for locating the faulty rules in model
                 transformations. We evaluate the feasibility and
                 accuracy of the approach by comparing the effectiveness
                 of 18 different state-of-the-art SBFL techniques at
                 locating faults in model transformations. Evaluation
                 results revealed that the best techniques, namely
                 Kulcynski2, Mountford, Ochiai, and Zoltar, lead the
                 debugger to inspect a maximum of three rules to locate
                 the bug in around 74\% of the cases. Furthermore, we
                 compare our approach with a static approach for fault
                 localization in model transformations, observing a
                 clear superiority of the proposed SBFL-based method.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Linares-Vasquez:2018:MOO,
  author =       "Mario Linares-V{\'a}squez and Gabriele Bavota and
                 Carlos Bernal-C{\'a}rdenas and Massimiliano {Di Penta}
                 and Rocco Oliveto and Denys Poshyvanyk",
  title =        "Multi-Objective Optimization of Energy Consumption of
                 {GUIs} in {Android} Apps",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "3",
  pages =        "14:1--14:??",
  month =        oct,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3241742",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:07 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The number of mobile devices sold worldwide has
                 exponentially increased in recent years, surpassing
                 that of personal computers in 2011. Such devices daily
                 download and run millions of apps that take advantage
                 of modern hardware features (e.g., multi-core
                 processors, large Organic Light-Emitting
                 Diode-OLED-screens, etc.) to offer exciting user
                 experiences. Clearly, there is a cost to pay in terms
                 of energy consumption and, in particular, of reduced
                 battery life. This has pushed researchers to
                 investigate how to reduce the energy consumption of
                 apps, for example, by optimizing the color palette used
                 in the app's GUI. Whilst past research in this area
                 aimed at optimizing energy while keeping an acceptable
                 level of contrast, this article proposes an approach,
                 named Gui Energy Multi-objective optiMization for
                 Android apps (GEMMA), for generating color palettes
                 using a multi-objective optimization technique, which
                 produces color solutions optimizing energy consumption
                 and contrast while using consistent colors with respect
                 to the original color palette. The empirical evaluation
                 demonstrates (i) substantial improvements in terms of
                 the three different objectives, (ii) a concrete
                 reduction of the energy consumption as assessed by a
                 hardware power monitor, (iii) the attractiveness of the
                 generated color compositions for apps' users, and (iv)
                 the suitability of GEMMA to be adopted in industrial
                 contexts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mechtaev:2018:TEA,
  author =       "Sergey Mechtaev and Xiang Gao and Shin Hwei Tan and
                 Abhik Roychoudhury",
  title =        "Test-Equivalence Analysis for Automatic Patch
                 Generation",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "4",
  pages =        "15:1--15:??",
  month =        nov,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3241980",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Automated program repair is a problem of finding a
                 transformation (called a patch) of a given incorrect
                 program that eliminates the observable failures. It has
                 important applications such as providing debugging
                 aids, automatically grading student assignments, and
                 patching security vulnerabilities. A common challenge
                 faced by existing repair techniques is scalability to
                 large patch spaces, since there are many candidate
                 patches that these techniques explicitly or implicitly
                 consider. The correctness criteria for program repair
                 is often given as a suite of tests. Current repair
                 techniques do not scale due to the large number of test
                 executions performed by the underlying search
                 algorithms. In this work, we address this problem by
                 introducing a methodology of patch generation based on
                 a test-equivalence relation (if two programs are
                 ``test-equivalent'' for a given test, they produce
                 indistinguishable results on this test). We propose two
                 test-equivalence relations based on runtime values and
                 dependencies, respectively, and present an algorithm
                 that performs on-the-fly partitioning of patches into
                 test-equivalence classes. Our experiments on real-world
                 programs reveal that the proposed methodology
                 drastically reduces the number of test executions and
                 therefore provides an order of magnitude efficiency
                 improvement over existing repair techniques, without
                 sacrificing patch quality.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sharma:2018:RWF,
  author =       "Abhishek Sharma and Yuan Tian and Agus Sulistya and
                 Dinusha Wijedasa and David Lo",
  title =        "Recommending Who to Follow in the Software Engineering
                 {Twitter} Space",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "4",
  pages =        "16:1--16:??",
  month =        nov,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3266426",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "With the advent of social media, developers are
                 increasingly using it in their software development
                 activities. Twitter is one of the popular social
                 mediums used by developers. A recent study by Singer et
                 al. found that software developers use Twitter to
                 ``keep up with the fast-paced development landscape.''
                 Unfortunately, due to the general-purpose nature of
                 Twitter, it's challenging for developers to use Twitter
                 for their development activities. Our survey with 36
                 developers who use Twitter in their development
                 activities highlights that developers are interested in
                 following specialized software gurus who share relevant
                 technical tweets. To help developers perform this task,
                 in this work we propose a recommendation system to
                 identify specialized software gurus. Our approach first
                 extracts different kinds of features that characterize
                 a Twitter user and then employs a two-stage
                 classification approach to generate a discriminative
                 model, which can differentiate specialized software
                 gurus in a particular domain from other Twitter users
                 that generate domain-related tweets (aka domain-related
                 Twitter users). We have investigated the effectiveness
                 of our approach in finding specialized software gurus
                 for four different domains (JavaScript, Android,
                 Python, and Linux) on a dataset of 86,824 Twitter users
                 who generate 5,517,878 tweets over 1 month. Our
                 approach can differentiate specialized software experts
                 from other domain-related Twitter users with an
                 F-Measure of up to 0.820. Compared with existing
                 Twitter domain expert recommendation approaches, our
                 proposed approach can outperform their F-Measure by at
                 least 7.63\%.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DeLara:2018:RML,
  author =       "Juan {De Lara} and Esther Guerra",
  title =        "Refactoring Multi-Level Models",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "4",
  pages =        "17:1--17:??",
  month =        nov,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3280985",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Multi-level modelling promotes flexibility in
                 modelling by enabling the use of several meta-levels
                 instead of just two, as is the case in mainstream
                 two-level modelling approaches. While this approach
                 leads to simpler models for some scenarios, it
                 introduces an additional degree of freedom as designers
                 can decide the meta-level where an element should
                 reside, having to ascertain the suitability of such
                 decisions. In this respect, model refactorings have
                 been successfully applied in the context of two-level
                 modelling to rearrange the elements of a model while
                 preserving its meaning. Following this idea, we propose
                 a catalogue of 17 novel refactorings specific to
                 multi-level models. Their objective is to help
                 designers in rearranging elements across and within
                 meta-levels and exploring the consequences. In this
                 article, we detail each refactoring in the catalogue,
                 show a classification across different dimensions, and
                 describe the support we provide in our M etaDepth tool.
                 We present two experiments to assess two aspects of our
                 refactorings. The first one validates the predicted
                 semantic side effects of the refactorings on the basis
                 of more than 210.000 refactoring applications. The
                 second one measures the impact of refactorings on three
                 quality attributes of multi-level models.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{VonRhein:2018:VAS,
  author =       "Alexander {Von Rhein} and J{\"o}rg Liebig and Andreas
                 Janker and Christian K{\"a}stner and Sven Apel",
  title =        "Variability-Aware Static Analysis at Scale: an
                 Empirical Study",
  journal =      j-TOSEM,
  volume =       "27",
  number =       "4",
  pages =        "18:1--18:??",
  month =        nov,
  year =         "2018",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3280986",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "The advent of variability management and generator
                 technology enables users to derive individual system
                 variants from a configurable code base by selecting
                 desired configuration options. This approach gives rise
                 to the generation of possibly billions of variants,
                 which, however, cannot be efficiently analyzed for bugs
                 and other properties with classic analysis techniques.
                 To address this issue, researchers and practitioners
                 have developed sampling heuristics and, recently,
                 variability-aware analysis techniques. While sampling
                 reduces the analysis effort significantly, the
                 information obtained is necessarily incomplete, and it
                 is unknown whether state-of-the-art sampling techniques
                 scale to billions of variants. Variability-aware
                 analysis techniques process the configurable code base
                 directly, exploiting similarities among individual
                 variants with the goal of reducing analysis effort.
                 However, while being promising, so far,
                 variability-aware analysis techniques have been applied
                 mostly only to small academic examples. To learn about
                 the mutual strengths and weaknesses of
                 variability-aware and sample-based static-analysis
                 techniques, we compared the two by means of seven
                 concrete control-flow and data-flow analyses, applied
                 to five real-world subject systems: B usybox, OpenSSL,
                 SQLite, the x86 Linux kernel, and uClibc. In
                 particular, we compare the efficiency (analysis
                 execution time) of the static analyses and their
                 effectiveness (potential bugs found). Overall, we found
                 that variability-aware analysis outperforms most
                 sample-based static-analysis techniques with respect to
                 efficiency and effectiveness. For example, checking all
                 variants of OpenSSL with a variability-aware static
                 analysis is faster than checking even only two variants
                 with an analysis that does not exploit similarities
                 among variants.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2019:EIE,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial from the Incoming {Editor-in-Chief}",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3301290",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1ee",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosenblum:2019:FEO,
  author =       "David S. Rosenblum",
  title =        "Farewell Editorial from the Outgoing
                 {Editor-in-Chief}",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3301288",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2019:OTS,
  author =       "Chunhui Wang and Fabrizio Pastore and Lionel Briand",
  title =        "Oracles for Testing Software Timeliness with
                 Uncertainty",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3280987",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Uncertainty in timing properties (e.g., detection time
                 of external events) is a common occurrence in embedded
                 software systems, since these systems interact with
                 complex physical environments. Such time uncertainty
                 leads to non-determinism. For example, time-triggered
                 operations may either generate different valid outputs
                 across different executions or experience failures
                 (e.g., results not being generated in the expected time
                 window) that occur only occasionally over many
                 executions. For these reasons, time uncertainty makes
                 the generation of effective test oracles for timing
                 requirements a challenging task. To address the above
                 challenge, we propose Stochastic Testing with Unique
                 Input Output Sequences, an approach for the automated
                 generation of stochastic oracles that verify the
                 capability of a software system to fulfill timing
                 constraints in the presence of time uncertainty. Such
                 stochastic oracles entail the statistical analysis of
                 repeated test case executions based on test output
                 probabilities predicted by means of statistical model
                 checking. Results from two industrial case studies in
                 the automotive domain demonstrate that this approach
                 improves the fault detection effectiveness of tests
                 suites derived from timed automata compared to
                 traditional approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Razzaq:2019:SEE,
  author =       "Abdul Razzaq and Asanka Wasala and Chris Exton and Jim
                 Buckley",
  title =        "The State of Empirical Evaluation in Static Feature
                 Location",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "2:1--2:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3280988",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Feature location (FL) is the task of finding the
                 source code that implements a specific, user-observable
                 functionality in a software system. It plays a key role
                 in many software maintenance tasks and a wide variety
                 of Feature Location Techniques (FLTs), which rely on
                 source code structure or textual analysis, have been
                 proposed by researchers. As FLTs evolve and more novel
                 FLTs are introduced, it is important to perform
                 comparison studies to investigate ``Which are the best
                 FLTs?'' However, an initial reading of the literature
                 suggests that performing such comparisons would be an
                 arduous process, based on the large number of
                 techniques to be compared, the heterogeneous nature of
                 the empirical designs, and the lack of transparency in
                 the literature. This article presents a systematic
                 review of 170 FLT articles, published between the years
                 2000 and 2015. Results of the systematic review
                 indicate that 95\% of the articles studied are directed
                 towards novelty, in that they propose a novel FLT.
                 Sixty-nine percent of these novel FLTs are evaluated
                 through standard empirical methods but, of those, only
                 9\% use baseline technique(s) in their evaluations to
                 allow cross comparison with other techniques. The
                 heterogeneity of empirical evaluation is also clearly
                 apparent: altogether, over 60 different FLT evaluation
                 metrics are used across the 170 articles, 272 subject
                 systems have been used, and 235 different benchmarks
                 employed. The review also identifies numerous user
                 input formats as contributing to the heterogeneity.
                 Analysis of the existing research also suggests that
                 only 27\% of the FLTs presented might be reproduced
                 from the published material. These findings suggest
                 that comparison across the existing body of FLT
                 evaluations is very difficult. We conclude by providing
                 guidelines for empirical evaluation of FLTs that may
                 ultimately help to standardise empirical research in
                 the field, cognisant of FLTs with different goals,
                 leveraging common practices in existing empirical
                 evaluations and allied with rationalisations. This is
                 seen as a step towards standardising evaluation in the
                 field, thus facilitating comparison across FLTs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arcuri:2019:RAA,
  author =       "Andrea Arcuri",
  title =        "{RESTful API} Automated Test Case Generation with
                 {EvoMaster}",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "3:1--3:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3293455",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "RESTful APIs are widespread in industry, especially in
                 enterprise applications developed with a microservice
                 architecture. A RESTful web service will provide data
                 via an API over the network using HTTP, possibly
                 interacting with databases and other web services.
                 Testing a RESTful API poses challenges, because
                 inputs/outputs are sequences of HTTP requests/responses
                 to a remote server. Many approaches in the literature
                 do black-box testing, because often the tested API is a
                 remote service whose code is not available. In this
                 article, we consider testing from the point of view of
                 the developers, who have full access to the code that
                 they are writing. Therefore, we propose a fully
                 automated white-box testing approach, where test cases
                 are automatically generated using an evolutionary
                 algorithm. Tests are rewarded based on code coverage
                 and fault-finding metrics. However, REST is not a
                 protocol but rather a set of guidelines on how to
                 design resources accessed over HTTP endpoints. For
                 example, there are guidelines on how related resources
                 should be structured with hierarchical URIs and how the
                 different HTTP verbs should be used to represent
                 well-defined actions on those resources. Test-case
                 generation for RESTful APIs that only rely on white-box
                 information of the source code might not be able to
                 identify how to create prerequisite resources needed
                 before being able to test some of the REST endpoints.
                 Smart sampling techniques that exploit the knowledge of
                 best practices in RESTful API design are needed to
                 generate tests with predefined structures to speed up
                 the search. We implemented our technique in a tool
                 called E voMaster, which is open source. Experiments on
                 five open-source, yet non-trivial, RESTful services
                 show that our novel technique automatically found 80
                 real bugs in those applications. However, obtained code
                 coverage is lower than the one achieved by the manually
                 written test suites already existing in those services.
                 Research directions on how to further improve such an
                 approach are therefore discussed, such as the handling
                 of SQL databases.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arora:2019:ALA,
  author =       "Chetan Arora and Mehrdad Sabetzadeh and Shiva Nejati
                 and Lionel Briand",
  title =        "An Active Learning Approach for Improving the Accuracy
                 of Automated Domain Model Extraction",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "4:1--4:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3293454",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Domain models are a useful vehicle for making the
                 interpretation and elaboration of natural-language
                 requirements more precise. Advances in natural-language
                 processing (NLP) have made it possible to automatically
                 extract from requirements most of the information that
                 is relevant to domain model construction. However,
                 alongside the relevant information, NLP extracts from
                 requirements a significant amount of information that
                 is superfluous (not relevant to the domain model). Our
                 objective in this article is to develop automated
                 assistance for filtering the superfluous information
                 extracted by NLP during domain model extraction. To
                 this end, we devise an active-learning-based approach
                 that iteratively learns from analysts' feedback over
                 the relevance and superfluousness of the extracted
                 domain model elements and uses this feedback to provide
                 recommendations for filtering superfluous elements. We
                 empirically evaluate our approach over three industrial
                 case studies. Our results indicate that, once trained,
                 our approach automatically detects an average of
                 \approx 45\% of the superfluous elements with a
                 precision of \approx 96\%. Since precision is very
                 high, the automatic recommendations made by our
                 approach are trustworthy. Consequently, analysts can
                 dispose of a considerable fraction --- nearly half ---
                 of the superfluous elements with minimal manual work.
                 The results are particularly promising, as they should
                 be considered in light of the non-negligible
                 subjectivity that is inherently tied to the notion of
                 relevance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Song:2019:SEI,
  author =       "Liyan Song and Leandro L. Minku and Xin Yao",
  title =        "Software Effort Interval Prediction via {Bayesian}
                 Inference and Synthetic Bootstrap Resampling",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "1",
  pages =        "5:1--5:??",
  month =        feb,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3295700",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  abstract =     "Software effort estimation (SEE) usually suffers from
                 inherent uncertainty arising from predictive model
                 limitations and data noise. Relying on point estimation
                 only may ignore the uncertain factors and lead project
                 managers (PMs) to wrong decision making. Prediction
                 intervals (PIs) with confidence levels (CLs) present a
                 more reasonable representation of reality, potentially
                 helping PMs to make better-informed decisions and
                 enable more flexibility in these decisions. However,
                 existing methods for PIs either have strong limitations
                 or are unable to provide informative PIs. To develop a
                 ``better'' effort predictor, we propose a novel PI
                 estimator called Synthetic Bootstrap ensemble of
                 Relevance Vector Machines (SynB-RVM) that adopts
                 Bootstrap resampling to produce multiple RVM models
                 based on modified training bags whose replicated data
                 projects are replaced by their synthetic counterparts.
                 We then provide three ways to assemble those RVM models
                 into a final probabilistic effort predictor, from which
                 PIs with CLs can be generated. When used as a point
                 estimator, SynB-RVM can either significantly outperform
                 or have similar performance compared with other
                 investigated methods. When used as an uncertain
                 predictor, SynB-RVM can achieve significantly narrower
                 PIs compared to its base learner RVM. Its hit rates and
                 relative widths are no worse than the other compared
                 methods that can provide uncertain estimation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ellis:2019:RFD,
  author =       "Samuel J. Ellis and Titus H. Klinge and James I.
                 Lathrop and Jack H. Lutz and Robyn R. Lutz and Andrew
                 S. Miner and Hugh D. Potter",
  title =        "Runtime Fault Detection in Programmed Molecular
                 Systems",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "6:1--6:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3295740",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3295740",
  abstract =     "Watchdog timers are devices that are commonly used to
                 monitor the health of safety-critical hardware and
                 software systems. Their primary function is to raise an
                 alarm if the monitored systems fail to emit periodic
                 ``heartbeats'' that signal their well-being. In this
                 article, we design and verify a molecular watchdog
                 timer for monitoring the health of programmed molecular
                 nanosystems. This raises new challenges, because our
                 molecular watchdog timer and the system that it
                 monitors both operate in the probabilistic environment
                 of chemical kinetics, where many failures are certain
                 to occur and it is especially hard to detect the
                 absence of a signal. Our molecular watchdog timer is
                 the result of an incremental design process that uses
                 goal-oriented requirements engineering, simulation,
                 stochastic analysis, and software verification tools.
                 We demonstrate the molecular watchdog's functionality
                 by having it monitor a molecular oscillator. Both the
                 molecular watchdog timer and the oscillator are
                 implemented as chemical reaction networks, which are
                 the current programming language of choice for many
                 molecular programming applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2019:Ea,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "6:1--6:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3317953",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3317953",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2019:UAJ,
  author =       "Yue Li and Tian Tan and Jingling Xue",
  title =        "Understanding and Analyzing {Java} Reflection",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "7:1--7:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3295739",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3295739",
  abstract =     "Java reflection has been widely used in a variety of
                 applications and frameworks. It allows a software
                 system to inspect and change the behaviour of its
                 classes, interfaces, methods, and fields at runtime,
                 enabling the software to adapt to dynamically changing
                 runtime environments. However, this dynamic language
                 feature imposes significant challenges to static
                 analysis, because the behaviour of reflection-rich
                 software is logically complex and statically hard to
                 predict. As a result, existing static analysis tools
                 either ignore reflection or handle it partially,
                 resulting in missed, important behaviours, i.e.,
                 unsound results. Therefore, improving or even achieving
                 soundness in static reflection analysis-an analysis
                 that infers statically the behaviour of reflective
                 code-will provide significant benefits to many analysis
                 clients, such as bug detectors, security analyzers, and
                 program verifiers. In this article, we provide a
                 comprehensive understanding of Java reflection through
                 examining its underlying concept, API, and real-world
                 usage, and, building on this, we introduce a new static
                 approach to resolving Java reflection effectively in
                 practice. We have implemented our reflection analysis
                 in an open-source tool, called SOLAR, and evaluated its
                 effectiveness extensively with large Java programs and
                 libraries. Our experimental results demonstrate that
                 SOLAR is able to (1) resolve reflection more soundly
                 than the state-of-the-art reflection analyses; (2)
                 automatically and accurately identify the parts of the
                 program where reflection is resolved unsoundly or
                 imprecisely; and (3) guide users to iteratively refine
                 the analysis results by using lightweight annotations
                 until their specific requirements are satisfied.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bjorner:2019:DAD,
  author =       "Dines Bj{\o}rner",
  title =        "Domain Analysis and Description Principles,
                 Techniques, and Modelling Languages",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "8:1--8:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3295738",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3295738",
  abstract =     "We present a method for analysing and describing
                 domains. By a domain we shall understand a rationally
                 describable segment of a human assisted reality, i.e.,
                 of the world, its physical parts: natural
                 [``God-given''] and artifactual [``human-made''], and
                 living species: plants and animals including, notably,
                 humans. These are endurants (``still''), as well as
                 perdurants (``alive''). Emphasis is placed on ``
                 human-assistedness,'' that is, that there is at least
                 one (human-made) artifact and, therefore, that humans
                 are a primary cause for change of endurant states as
                 well as perdurant behaviours. By a method we shall mean
                 a set of principles of analysis and for selecting and
                 applying a number of techniques and tools in the
                 construction of some artifact, say a domain
                 description. We shall present a method for constructing
                 domain descriptions. Among the tools we shall only be
                 concerned with are the analysis and synthesis
                 languages. Domain science and engineering marks a new
                 area of computing science. Just as we are formalising
                 the syntax and semantics of programming languages, so
                 we are formalising the syntax and semantics of
                 human-assisted domains. Just as physicists are studying
                 the natural physical world, endowing it with
                 mathematical models, so we, computing scientists, are
                 studying these domains, endowing them with mathematical
                 models, A difference between the endeavours of
                 physicists and ours lies in the tools: The physics
                 models are based on classical mathematics, differential
                 equations and integrals, and so on; our models are
                 based on mathematical logic, set theory, and algebra
                 [1]. Where physicists thus classically use a variety of
                 differential and integral calculi to model the physical
                 world, we shall be using the analysis and description
                 calculi presented in this article to model primarily
                 artifactual domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wagner:2019:SQR,
  author =       "Stefan Wagner and Daniel M{\'e}ndez Fern{\'a}ndez and
                 Michael Felderer and Antonio Vetr{\`o} and Marcos
                 Kalinowski and Roel Wieringa and Dietmar Pfahl and
                 Tayana Conte and Marie-Therese Christiansson and
                 Desmond Greer and Casper Lassenius and Tomi
                 M{\"a}nnist{\"o} and Maleknaz Nayebi and Markku Oivo
                 and Birgit Penzenstadler and Rafael Prikladnicki and
                 Guenther Ruhe and Andr{\'e} Schekelmann and Sagar Sen
                 and Rodrigo Sp{\'\i}nola and Ahmed Tuzcu and Jose Luis
                 {De La Vara} and Dietmar Winkler",
  title =        "Status Quo in Requirements Engineering: a Theory and a
                 Global Family of Surveys",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "9:1--9:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3306607",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3306607",
  abstract =     "Requirements Engineering (RE) has established itself
                 as a software engineering discipline over the past
                 decades. While researchers have been investigating the
                 RE discipline with a plethora of empirical studies,
                 attempts to systematically derive an empirical theory
                 in context of the RE discipline have just recently been
                 started. However, such a theory is needed if we are to
                 define and motivate guidance in performing high quality
                 RE research and practice. We aim at providing an
                 empirical and externally valid foundation for a theory
                 of RE practice, which helps software engineers
                 establish effective and efficient RE processes in a
                 problem-driven manner. We designed a survey instrument
                 and an engineer-focused theory that was first piloted
                 in Germany and, after making substantial modifications,
                 has now been replicated in 10 countries worldwide. We
                 have a theory in the form of a set of propositions
                 inferred from our experiences and available studies, as
                 well as the results from our pilot study in Germany. We
                 evaluate the propositions with bootstrapped confidence
                 intervals and derive potential explanations for the
                 propositions. In this article, we report on the design
                 of the family of surveys, its underlying theory, and
                 the full results obtained from the replication studies
                 conducted in 10 countries with participants from 228
                 organisations. Our results represent a substantial step
                 forward towards developing an empirical theory of RE
                 practice. The results reveal, for example, that there
                 are no strong differences between organisations in
                 different countries and regions, that interviews,
                 facilitated meetings and prototyping are the most used
                 elicitation techniques, that requirements are often
                 documented textually, that traces between requirements
                 and code or design documents are common, that
                 requirements specifications themselves are rarely
                 changed and that requirements engineering (process)
                 improvement endeavours are mostly internally driven.
                 Our study establishes a theory that can be used as
                 starting point for many further studies for more
                 detailed investigations. Practitioners can use the
                 results as theory-supported guidance on selecting
                 suitable RE methods and techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2019:IMA,
  author =       "Jian-Min Jiang and Huibiao Zhu and Qin Li and Yongxin
                 Zhao and Zhong Hong and Shi Zhang and Ping Gong",
  title =        "Isolation Modeling and Analysis Based on Mobility",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "10:1--10:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3306606",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3306606",
  abstract =     "In a mobile system, mobility refers to a change in
                 position of a mobile object with respect to time and
                 its reference point, whereas isolation means the
                 isolation relationship between mobile objects under
                 some scheduling policies. Inspired by event-based
                 formal models and the ambient calculus, we first
                 propose the two types of special events, entering and
                 exiting an ambient, as movement events to model and
                 analyze mobility. Based on mobility, we then introduce
                 the notion of the isolation of mobile objects for
                 ambients. To ensure the isolation, a priority policy
                 needs to be used to schedule the movement of mobile
                 objects. However, traditional scheduling policies focus
                 on task scheduling and depend on the strong hypothesis:
                 The scheduled tasks are independent-that is, the
                 scheduled tasks do not affect each other. In a
                 practical mobile system, mobile objects and ambients
                 interact with each other. It is difficult to separate a
                 mobile system into independent tasks. We finally
                 present an automatic approach for generating a priority
                 scheduling policy without considering the preceding
                 assumption. The approach can guarantee the isolation of
                 the mobile objects for ambients in a mobile system.
                 Experiments demonstrate these results.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Czepa:2019:HUP,
  author =       "Christoph Czepa and Uwe Zdun",
  title =        "How Understandable Are Pattern-based Behavioral
                 Constraints for Novice Software Designers?",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "2",
  pages =        "11:1--11:??",
  month =        apr,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3306608",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3306608",
  abstract =     "This article reports a controlled experiment with 116
                 participants on the understandability of representative
                 graphical and textual pattern-based behavioral
                 constraint representations from the viewpoint of novice
                 software designers. Particularly, graphical and textual
                 behavioral constraint patterns present in the
                 declarative business process language Declare and
                 textual behavioral constraints based on Property
                 Specification Patterns are the subjects of this study.
                 In addition to measuring the understandability
                 construct, this study assesses subjective aspects such
                 as perceived difficulties regarding learning and
                 application of the tested approaches. An interesting
                 finding of this study is the overall low achieved
                 correctness in the experimental tasks, which seems to
                 indicate that pattern-based behavioral constraint
                 representations are hard to understand for novice
                 software designers in the absence of additional
                 supportive measures. The results of the descriptive
                 statistics regarding achieved correctness are slightly
                 in favor of the textual representations, but the
                 inference statistics do not indicate any significant
                 differences in terms of understandability between
                 graphical and textual behavioral constraint
                 representations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2019:Eb,
  author =       "Mauro Pezz{\'e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "12:1--12:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3339833",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3339833",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Reuling:2019:AWP,
  author =       "Dennis Reuling and Udo Kelter and Johannes B{\"u}rdek
                 and Malte Lochau",
  title =        "Automated {$N$-way} Program Merging for Facilitating
                 Family-based Analyses of Variant-rich Software",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "13:1--13:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3313789",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3313789",
  abstract =     "Nowadays software tends to come in many different, yet
                 similar variants, often derived from a common code base
                 via clone-and-own. Family-based-analysis strategies
                 have recently shown very promising potential for
                 improving efficiency in applying quality-assurance
                 techniques to such variant-rich programs, as compared
                 to variant-by-variant approaches. Unfortunately, these
                 strategies require a single program representation
                 superimposing all program variants in a syntactically
                 well-formed, semantically sound, and variant-preserving
                 manner, which is usually not available and manually
                 hard to obtain in practice. In this article, we present
                 a novel methodology, called SiMPOSE, for automatically
                 generating superimpositions of existing program
                 variants to facilitate family-based analyses of
                 variant-rich software. To this end, we propose a novel
                 N-way model-merging methodology to integrate the
                 control-flow automaton (CFA) representations of N given
                 variants of a C program into one unified CFA
                 representation. CFA constitute a unified program
                 abstraction used by many recent software-analysis tools
                 for automated quality assurance. To cope with the
                 inherent complexity of N-way model-merging, our
                 approach (1) utilizes principles of
                 similarity-propagation to reduce the number of
                 potential N-way matches, and (2) enables us to
                 decompose a set of N variants into arbitrary subsets
                 and to incrementally derive an N-way superimposition
                 from partial superimpositions. We apply our tool
                 implementation of SiMPOSE to a selection of realistic C
                 programs, frequently considered for experimental
                 evaluation of program-analysis techniques. In
                 particular, we investigate applicability and
                 efficiency/effectiveness trade-offs of our approach by
                 applying SiMPOSE in the context of family-based
                 unit-test generation as well as model-checking as
                 sample program-analysis techniques. Our experimental
                 results reveal very impressive efficiency improvements
                 by an average factor of up to 2.6 for test-generation
                 and up to 2.4 for model-checking under stable
                 effectiveness, as compared to variant-by-variant
                 approaches, thus amortizing the additional effort
                 required for merging. In addition, our results show
                 that merging all N variants at once produces, in almost
                 all cases, clearly more precise results than
                 incremental step-wise 2-way merging. Finally, our
                 comparison with major existing N-way merging techniques
                 shows that SiMPOSE constitutes, in most cases, the best
                 efficiency/effectiveness trade-off.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sheng:2019:TPA,
  author =       "Feng Sheng and Huibiao Zhu and Jifeng He and Zongyuan
                 Yang and Jonathan P. Bowen",
  title =        "Theoretical and Practical Aspects of Linking
                 Operational and Algebraic Semantics for {MDESL}",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "14:1--14:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3295699",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3295699",
  abstract =     "Verilog is a hardware description language (HDL) that
                 has been standardized and widely used in industry.
                 Multithreaded discrete event simulation language
                 (MDESL) is a Verilog-like language. It contains
                 interesting features such as event-driven computation
                 and shared-variable concurrency. This article considers
                 how the algebraic semantics links with the operational
                 semantics for MDESL. Our approach is from both the
                 theoretical and practical aspects. The link is
                 proceeded by deriving the operational semantics from
                 the algebraic semantics. First, we present the
                 algebraic semantics for MDESL. We introduce the concept
                 of head normal form. Second, we present the strategy of
                 deriving operational semantics from algebraic
                 semantics. We also investigate the soundness and
                 completeness of the derived operational semantics with
                 respect to the derivation strategy. Our theoretical
                 approach is complemented by a practical one, and we use
                 the theorem proof assistant Coq to formalize the
                 algebraic laws and the derived operational semantics.
                 Meanwhile, the soundness and completeness of the
                 derived operational semantics is also verified via the
                 mechanical approach in Coq. Our approach is a novel way
                 to formalize and verify the correctness and equivalence
                 of different semantics for MDESL in both a theoretical
                 approach and a practical approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ren:2019:NNB,
  author =       "Xiaoxue Ren and Zhenchang Xing and Xin Xia and David
                 Lo and Xinyu Wang and John Grundy",
  title =        "Neural Network-based Detection of Self-Admitted
                 Technical Debt: From Performance to Explainability",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "15:1--15:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3324916",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3324916",
  abstract =     "Technical debt is a metaphor to reflect the tradeoff
                 software engineers make between short-term benefits and
                 long-term stability. Self-admitted technical debt
                 (SATD), a variant of technical debt, has been proposed
                 to identify debt that is intentionally introduced
                 during software development, e.g., temporary fixes and
                 workarounds. Previous studies have leveraged
                 human-summarized patterns (which represent n-gram
                 phrases that can be used to identify SATD) or
                 text-mining techniques to detect SATD in source code
                 comments. However, several characteristics of SATD
                 features in code comments, such as vocabulary
                 diversity, project uniqueness, length, and semantic
                 variations, pose a big challenge to the accuracy of
                 pattern or traditional text-mining-based SATD
                 detection, especially for cross-project deployment.
                 Furthermore, although traditional text-mining-based
                 method outperforms pattern-based method in prediction
                 accuracy, the text features it uses are less intuitive
                 than human-summarized patterns, which makes the
                 prediction results hard to explain. To improve the
                 accuracy of SATD prediction, especially for
                 cross-project prediction, we propose a Convolutional
                 Neural Network-- (CNN) based approach for classifying
                 code comments as SATD or non-SATD. To improve the
                 explainability of our model's prediction results, we
                 exploit the computational structure of CNNs to identify
                 key phrases and patterns in code comments that are most
                 relevant to SATD. We have conducted an extensive set of
                 experiments with 62,566 code comments from 10
                 open-source projects and a user study with 150 comments
                 of another three projects. Our evaluation confirms the
                 effectiveness of different aspects of our approach and
                 its superior performance, generalizability,
                 adaptability, and explainability over current
                 state-of-the-art traditional text-mining-based methods
                 for SATD classification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2019:VQS,
  author =       "Pengfei Gao and Jun Zhang and Fu Song and Chao Wang",
  title =        "Verifying and Quantifying Side-channel Resistance of
                 Masked Software Implementations",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "16:1--16:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3330392",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3330392",
  abstract =     "Power side-channel attacks, capable of deducing secret
                 data using statistical analysis, have become a serious
                 threat. Random masking is a widely used countermeasure
                 for removing the statistical dependence between secret
                 data and side-channel information. Although there are
                 techniques for verifying whether a piece of software
                 code is perfectly masked, they are limited in accuracy
                 and scalability. To bridge this gap, we propose a
                 refinement-based method for verifying masking
                 countermeasures. Our method is more accurate than prior
                 type-inference-based approaches and more scalable than
                 prior model-counting-based approaches using SAT or SMT
                 solvers. Indeed, our method can be viewed as a gradual
                 refinement of a set of type-inference rules for
                 reasoning about distribution types. These rules are
                 kept abstract initially to allow fast deduction and
                 then made concrete when the abstract version is not
                 able to resolve the verification problem. We also
                 propose algorithms for quantifying the amount of
                 side-channel information leakage from a software
                 implementation using the notion of quantitative masking
                 strength. We have implemented our method in a software
                 tool and evaluated it on cryptographic benchmarks
                 including AES and MAC-Keccak. The experimental results
                 show that our method significantly outperforms
                 state-of-the-art techniques in terms of accuracy and
                 scalability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tramontana:2019:DEO,
  author =       "Porfirio Tramontana and Domenico Amalfitano and Nicola
                 Amatucci and Atif Memon and Anna Rita Fasolino",
  title =        "Developing and Evaluating Objective Termination
                 Criteria for Random Testing",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "17:1--17:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3339836",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3339836",
  abstract =     "Random testing is a software testing technique through
                 which programs are tested by generating and executing
                 random inputs. Because of its unstructured nature, it
                 is difficult to determine when to stop a random testing
                 process. Faults may be missed if the process is stopped
                 prematurely, and resources may be wasted if the process
                 is run too long. In this article, we propose two
                 promising termination criteria, ``All Equivalent''
                 (AEQ) and ``All Included in One'' (AIO), applicable to
                 random testing. These criteria stop random testing once
                 the process has reached a code-coverage-based
                 saturation point after which additional testing effort
                 is unlikely to provide additional effectiveness. We
                 model and implement them in the context of a general
                 random testing process composed of independent random
                 testing sessions. Thirty-six experiments involving GUI
                 testing and unit testing of Java applications have
                 demonstrated that the AEQ criteria is generally able to
                 stop the process when a code coverage equal or very
                 near to the saturation level is reached, while AIO is
                 able to stop the process earlier in cases it reaches
                 the saturation level of coverage. In addition, the
                 performance of the two criteria has been compared
                 against other termination criteria adopted in the
                 literature.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Antonino:2019:EVC,
  author =       "Pedro Antonino and Thomas Gibson-Robinson and A. W.
                 Roscoe",
  title =        "Efficient Verification of Concurrent Systems Using
                 Synchronisation Analysis and {SAT\slash SMT} Solving",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "3",
  pages =        "18:1--18:??",
  month =        aug,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3335149",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3335149",
  abstract =     "This article investigates how the use of
                 approximations can make the formal verification of
                 concurrent systems scalable. We propose the idea of
                 synchronisation analysis to automatically capture
                 global invariants and approximate reachability. We
                 calculate invariants on how components participate on
                 global system synchronisations and use a notion of
                 consistency between these invariants to establish
                 whether components can effectively communicate to reach
                 some system state. Our synchronisation-analysis
                 techniques try to show either that a system state is
                 unreachable by demonstrating that components cannot
                 agree on the order they participate in system rules or
                 that a system state is unreachable by demonstrating
                 components cannot agree on the number of times they
                 participate on system rules. These fully automatic
                 techniques are applied to check deadlock and
                 local-deadlock freedom in the PairStatic framework. It
                 extends Pair (a recent framework where we use pure
                 pairwise analysis of components and SAT checkers to
                 check deadlock and local-deadlock freedom) with
                 techniques to carry out synchronisation analysis. So,
                 not only can it compute the same local invariants that
                 Pair does, it can leverage global invariants found by
                 synchronisation analysis, thereby improving the
                 reachability approximation and tightening our
                 verifications. We implement PairStatic in our DeadlOx
                 tool using SAT/SMT and demonstrate the improvements
                 they create in checking (local) deadlock freedom.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2019:Ec,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "19:1--19:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3363297",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3363297",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tufano:2019:ESL,
  author =       "Michele Tufano and Cody Watson and Gabriele Bavota and
                 Massimiliano {Di Penta} and Martin White and Denys
                 Poshyvanyk",
  title =        "An Empirical Study on Learning Bug-Fixing Patches in
                 the Wild via Neural Machine Translation",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "19:1--19:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3340544",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3340544",
  abstract =     "Millions of open source projects with numerous bug
                 fixes are available in code repositories. This
                 proliferation of software development histories can be
                 leveraged to learn how to fix common programming bugs.
                 To explore such a potential, we perform an empirical
                 study to assess the feasibility of using Neural Machine
                 Translation techniques for learning bug-fixing patches
                 for real defects. First, we mine millions of bug-fixes
                 from the change histories of projects hosted on GitHub
                 in order to extract meaningful examples of such
                 bug-fixes. Next, we abstract the buggy and
                 corresponding fixed code, and use them to train an
                 Encoder-Decoder model able to translate buggy code into
                 its fixed version. In our empirical investigation, we
                 found that such a model is able to fix thousands of
                 unique buggy methods in the wild. Overall, this model
                 is capable of predicting fixed patches generated by
                 developers in 9--50\% of the cases, depending on the
                 number of candidate patches we allow it to generate.
                 Also, the model is able to emulate a variety of
                 different Abstract Syntax Tree operations and generate
                 candidate patches in a split second.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bernaschina:2019:VDI,
  author =       "Carlo Bernaschina and Emanuele Falzone and Piero
                 Fraternali and Sergio Luis Herrera Gonzalez",
  title =        "The Virtual Developer: Integrating Code Generation and
                 Manual Development with Conflict Resolution",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "20:1--20:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3340545",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3340545",
  abstract =     "Model Driven Development (MDD) requires proper tools
                 to derive the implementation code from the application
                 models. However, the integration of handwritten and
                 generated code is a long-standing issue that affects
                 the adoption of MDD in the industry. This article
                 presents a model and code co-evolution approach that
                 addresses such a problem a posteriori, using the
                 standard collision detection capabilities of Version
                 Control Systems to support the semi-automatic merge of
                 the two types of code. We assess the proposed approach
                 by contrasting it with the more traditional
                 template-based, forward-engineering process, adopted by
                 most MDD tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lara:2019:ARM,
  author =       "Juan {De Lara} and Esther Guerra and Davide {Di
                 Ruscio} and Juri {Di Rocco} and Jes{\'u}s S'nchez
                 Cuadrado and Ludovico Iovino and Alfonso Pierantonio",
  title =        "Automated Reuse of Model Transformations through
                 Typing Requirements Models",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "21:1--21:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3340108",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3340108",
  abstract =     "Model transformations are key elements of model-driven
                 engineering, where they are used to automate the
                 manipulation of models. However, they are typed with
                 respect to concrete source and target meta-models,
                 making their reuse for other (even similar) meta-models
                 challenging. To improve this situation, we propose
                 capturing the typing requirements for reusing a
                 transformation with other meta-models by the notion of
                 a typing requirements model (TRM). A TRM describes the
                 prerequisites that a model transformation imposes on
                 the source and target meta-models to obtain a correct
                 typing. The key observation is that any meta-model pair
                 that satisfies the TRM is a valid reuse context for the
                 transformation at hand. A TRM is made of two domain
                 requirement models (DRMs) describing the requirements
                 for the source and target meta-models, and a
                 compatibility model expressing dependencies between
                 them. We define a notion of refinement between DRMs and
                 see meta-models as a special case of DRM. We provide a
                 catalogue of valid refinements and describe how to
                 automatically extract a TRM from an ATL transformation.
                 The approach is supported by our tool TOTEM. We report
                 on two experiments-based on transformations developed
                 by third parties and meta-model mutation
                 techniques-validating the correctness and completeness
                 of our TRM extraction procedure and confirming the
                 power of TRMs to encode variability and support
                 flexible reuse.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2019:RNF,
  author =       "He Jiang and Jingxuan Zhang and Xiaochen Li and Zhilei
                 Ren and David Lo and Xindong Wu and Zhongxuan Luo",
  title =        "Recommending New Features from Mobile App
                 Descriptions",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "22:1--22:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3344158",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3344158",
  abstract =     "The rapidly evolving mobile applications (apps) have
                 brought great demand for developers to identify new
                 features by inspecting the descriptions of similar apps
                 and acquire missing features for their apps.
                 Unfortunately, due to the huge number of apps, this
                 manual process is time-consuming and unscalable. To
                 help developers identify new features, we propose a new
                 approach named SAFER. In this study, we first develop a
                 tool to automatically extract features from app
                 descriptions. Then, given an app, we leverage the topic
                 model to identify its similar apps based on the
                 extracted features and API names of apps. Finally, we
                 design a feature recommendation algorithm to aggregate
                 and recommend the features of identified similar apps
                 to the specified app. Evaluated over a collection of
                 533 annotated features from 100 apps, SAFER achieves a
                 Hit@15 score of up to 78.68\% and outperforms the
                 baseline approach KNN+ by 17.23\% on average. In
                 addition, we also compare SAFER against a typical
                 technique of recommending features from user reviews,
                 i.e., CLAP. Experimental results reveal that SAFER is
                 superior to CLAP by 23.54\% in terms of Hit@15.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kim:2019:PLR,
  author =       "Yunho Kim and Seokhyeon Mun and Shin Yoo and Moonzoo
                 Kim",
  title =        "Precise Learn-to-Rank Fault Localization Using Dynamic
                 and Static Features of Target Programs",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "23:1--23:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3345628",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3345628",
  abstract =     "Finding the root cause of a bug requires a significant
                 effort from developers. Automated fault localization
                 techniques seek to reduce this cost by computing the
                 suspiciousness scores (i.e., the likelihood of program
                 entities being faulty). Existing techniques have been
                 developed by utilizing input features of specific types
                 for the computation of suspiciousness scores, such as
                 program spectrum or mutation analysis results. This
                 article presents a novel learn-to-rank fault
                 localization technique called PRecise
                 machINe-learning-based fault loCalization tEchnique
                 (PRINCE). PRINCE uses genetic programming (GP) to
                 combine multiple sets of localization input features
                 that have been studied separately until now. For
                 dynamic features, PRINCE encompasses both Spectrum
                 Based Fault Localization (SBFL) and Mutation Based
                 Fault Localization (MBFL) techniques. It also uses
                 static features, such as dependency information and
                 structural complexity of program entities. All such
                 information is used by GP to train a ranking model for
                 fault localization. The empirical evaluation on 65
                 real-world faults from CoREBench, 84 artificial faults
                 from SIR, and 310 real-world faults from Defects4J
                 shows that PRINCE outperforms the state-of-the-art
                 SBFL, MBFL, and learn-to-rank techniques significantly.
                 PRINCE localizes a fault after reviewing 2.4\% of the
                 executed statements on average (4.2 and 3.0 times more
                 precise than the best of the compared SBFL and MBFL
                 techniques, respectively). Also, PRINCE ranks 52.9\% of
                 the target faults within the top ten suspicious
                 statements.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tian:2019:DTC,
  author =       "Cong Tian and Chu Chen and Zhenhua Duan and Liang
                 Zhao",
  title =        "Differential Testing of Certificate Validation in
                 {SSL\slash TLS} Implementations: an {RFC}-guided
                 Approach",
  journal =      j-TOSEM,
  volume =       "28",
  number =       "4",
  pages =        "24:1--24:??",
  month =        oct,
  year =         "2019",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3355048",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue Oct 22 07:57:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3355048",
  abstract =     "Certificate validation in Secure Sockets Layer or
                 Transport Layer Security protocol (SSL/TLS) is critical
                 to Internet security. Thus, it is significant to check
                 whether certificate validation in SSL/TLS
                 implementations is correctly implemented. With this
                 motivation, we propose a novel differential testing
                 approach that is based on the standard Request for
                 Comments (RFC). First, rules of certificates are
                 extracted automatically from RFCs. Second, low-level
                 test cases are generated through dynamic symbolic
                 execution. Third, high-level test cases, i.e.,
                 certificates, are assembled automatically. Finally,
                 with the assembled certificates being test cases,
                 certificate validations in SSL/TLS implementations are
                 tested to reveal latent vulnerabilities or bugs. Our
                 approach named RFCcert has the following advantages:
                 (1) certificates of RFCcert are discrepancy-targeted,
                 since they are assembled according to standards instead
                 of genetics; (2) with the obtained certificates,
                 RFCcert not only reveals the invalidity of traditional
                 differential testing but also is able to conduct
                 testing that traditional differential testing cannot
                 do; and (3) the supporting tool of RFCcert has been
                 implemented and extensive experiments show that the
                 approach is effective in finding bugs of SSL/TLS
                 implementations. In addition, by providing seed
                 certificates for mutation approaches with RFCcert, the
                 ability of mutation approaches in finding distinct
                 discrepancies is significantly enhanced.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{El-Hokayem:2020:MDS,
  author =       "Antoine El-Hokayem and Yli{\`e}s Falcone",
  title =        "On the Monitoring of Decentralized Specifications:
                 Semantics, Properties, Analysis, and Simulation",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "1:1--1:57",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3355181",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3355181",
  abstract =     "We introduce two complementary approaches to monitor
                 decentralized systems. The first approach relies on
                 systems with a centralized specification, i.e., when
                 the specification is written for the behavior of the
                 entire system. To do so, our approach \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hierons:2020:MOT,
  author =       "Robert M. Hierons and Miqing Li and Xiaohui Liu and
                 Jose Antonio Parejo and Sergio Segura and Xin Yao",
  title =        "Many-Objective Test Suite Generation for Software
                 Product Lines",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "2:1--2:46",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3361146",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3361146",
  abstract =     "A Software Product Line (SPL) is a set of products
                 built from a number of features, the set of valid
                 products being defined by a feature model. Typically,
                 it does not make sense to test all products defined by
                 an SPL and one instead chooses a set of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2020:HCT,
  author =       "Lin Chen and Di Wu and Wanwangying Ma and Yuming Zhou
                 and Baowen Xu and Hareton Leung",
  title =        "How {C++} Templates Are Used for Generic Programming:
                 an Empirical Study on 50 Open Source Systems",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "3:1--3:49",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3356579",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3356579",
  abstract =     "Generic programming is a key paradigm for developing
                 reusable software components. The inherent support for
                 generic constructs is therefore important in
                 programming languages. As for C++, the generic
                 construct, templates, has been supported since the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yan:2020:AGS,
  author =       "Gaogao Yan and Li Jiao and Shuling Wang and Lingtai
                 Wang and Naijun Zhan",
  title =        "Automatically Generating {SystemC} Code from {HCSP}
                 Formal Models",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "4:1--4:39",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3360002",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360002",
  abstract =     "In model-driven design of embedded systems, how to
                 generate code from high-level control models seamlessly
                 and correctly is challenging. This is because hybrid
                 systems are involved with continuous evolution,
                 discrete jumps, and the complicated \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yuan:2020:TBE,
  author =       "Yuan Yuan and Wolfgang Banzhaf",
  title =        "Toward Better Evolutionary Program Repair: an
                 Integrated Approach",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "5:1--5:53",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3360004",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360004",
  abstract =     "Bug repair is a major component of software
                 maintenance, which requires a huge amount of manpower.
                 Evolutionary computation, particularly genetic
                 programming (GP), is a class of promising techniques
                 for automating this time-consuming and expensive
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Haas:2020:SAA,
  author =       "Roman Haas and Rainer Niedermayr and Tobias Roehm and
                 Sven Apel",
  title =        "Is Static Analysis Able to Identify Unnecessary Source
                 Code?",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "6:1--6:23",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3368267",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3368267",
  abstract =     "Grown software systems often contain code that is not
                 necessary anymore. Such unnecessary code wastes
                 resources during development and maintenance, for
                 example, when preparing code for migration or
                 certification. Running a profiler may reveal code that
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kafali:2020:DSS,
  author =       "{\"O}zg{\"u}r Kafali and Nirav Ajmeri and Munindar P.
                 Singh",
  title =        "{DESEN}: Specification of Sociotechnical Systems via
                 Patterns of Regulation and Control",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "1",
  pages =        "7:1--7:50",
  month =        feb,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3365664",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Feb 6 08:32:22 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3365664",
  abstract =     "We address the problem of engineering a sociotechnical
                 system (STS) with respect to its stakeholders'
                 requirements. We motivate a two-tier STS conception
                 composed of a technical tier that provides control
                 mechanisms and describes what actions are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2020:Ea,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "8e:1--8e:1",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3383775",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3383775",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cai:2020:AIM,
  author =       "Haipeng Cai",
  title =        "Assessing and Improving Malware Detection
                 Sustainability through App Evolution Studies",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "8:1--8:28",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3371924",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3371924",
  abstract =     "Machine learning-based classification dominates
                 current malware detection approaches for Android.
                 However, due to the evolution of both the Android
                 platform and its user apps, existing such techniques
                 are widely limited by their reliance on new malware
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Beschastnikh:2020:VDS,
  author =       "Ivan Beschastnikh and Perry Liu and Albert Xing and
                 Patty Wang and Yuriy Brun and Michael D. Ernst",
  title =        "Visualizing Distributed System Executions",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "9:1--9:38",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3375633",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3375633",
  abstract =     "Distributed systems pose unique challenges for
                 software developers. Understanding the system's
                 communication topology and reasoning about concurrent
                 activities of system hosts can be difficult. The
                 standard approach, analyzing system logs, can be a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ali:2020:QIS,
  author =       "Shaukat Ali and Paolo Arcaini and Dipesh Pradhan and
                 Safdar Aqeel Safdar and Tao Yue",
  title =        "Quality Indicators in Search-based Software
                 Engineering: an Empirical Evaluation",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "10:1--10:29",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3375636",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3375636",
  abstract =     "Search-Based Software Engineering (SBSE) researchers
                 who apply multi-objective search algorithms (MOSAs)
                 often assess the quality of solutions produced by MOSAs
                 with one or more quality indicators (QIs). However,
                 SBSE lacks evidence providing insights \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Soltana:2020:PCS,
  author =       "Ghanem Soltana and Mehrdad Sabetzadeh and Lionel C.
                 Briand",
  title =        "Practical Constraint Solving for Generating System
                 Test Data",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "11:1--11:48",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3381032",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3381032",
  abstract =     "The ability to generate test data is often a necessary
                 prerequisite for automated software testing. For the
                 generated data to be fit for their intended purpose,
                 the data usually have to satisfy various logical
                 constraints. When testing is performed at a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kapur:2020:DES,
  author =       "Ritu Kapur and Balwinder Sodhi",
  title =        "A Defect Estimator for Source Code: Linking Defect
                 Reports with Programming Constructs Usage Metrics",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "12:1--12:35",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3384517",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3384517",
  abstract =     "An important issue faced during software development
                 is to identify defects and the properties of those
                 defects, if found, in a given source file. Determining
                 defectiveness of source code assumes significance due
                 to its implications on software \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2020:PNF,
  author =       "Yangguang Li and Zhen Ming (Jack) Jiang and Heng Li
                 and Ahmed E. Hassan and Cheng He and Ruirui Huang and
                 Zhengda Zeng and Mian Wang and Pinan Chen",
  title =        "Predicting Node Failures in an Ultra-Large-Scale Cloud
                 Computing Platform: an {AIOps} Solution",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "2",
  pages =        "13:1--13:24",
  month =        apr,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3385187",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Apr 30 10:40:53 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3385187",
  abstract =     "Many software services today are hosted on cloud
                 computing platforms, such as Amazon EC2, due to many
                 benefits like reduced operational costs. However, node
                 failures in these platforms can impact the availability
                 of their hosted services and potentially \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2020:Eb,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "14e:1--14e:1",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3402931",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3402931",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2020:KDI,
  author =       "Guanhua Wang and Sudipta Chattopadhyay and Arnab Kumar
                 Biswas and Tulika Mitra and Abhik Roychoudhury",
  title =        "{KLEESpectre}: Detecting Information Leakage through
                 Speculative Cache Attacks via Symbolic Execution",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "14:1--14:31",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3385897",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3385897",
  abstract =     "Spectre-style attacks disclosed in early 2018 expose
                 data leakage scenarios via cache side channels.
                 Specifically, speculatively executed paths due to
                 branch mis-prediction may bring secret data into the
                 cache, which are then exposed via cache side channels
                 even after the speculative execution is squashed.
                 Symbolic execution is a well-known test generation
                 method to cover program paths at the level of the
                 application software. In this article, we extend
                 symbolic execution with modeling of cache and
                 speculative execution. Our tool KLEESPECTRE, built on
                 top of the KLEE symbolic execution engine, can thus
                 provide a testing engine to check for data leakage
                 through the cache side channel as shown via Spectre
                 attacks. Our symbolic cache model can verify whether
                 the sensitive data leakage due to speculative execution
                 can be observed by an attacker at a given program
                 point. Our experiments show that KLEESPECTRE can
                 effectively detect data leakage along speculatively
                 executed paths and our cache model can make the leakage
                 detection more precise.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Taymouri:2020:CAW,
  author =       "Farbod Taymouri and Josep Carmona",
  title =        "Computing Alignments of Well-Formed Process Models
                 using Local Search",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "15:1--15:41",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3394056",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3394056",
  abstract =     "The alignment of observed and modeled behavior is an
                 essential element for organizations, since it opens the
                 door for conformance checking and enhancement of
                 processes. The state-of-the-art technique for computing
                 alignments has exponential time and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2020:UED,
  author =       "Zhendong Wang and Yang Feng and Yi Wang and James A.
                 Jones and David Redmiles",
  title =        "Unveiling Elite Developers' Activities in Open Source
                 Projects",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "16:1--16:35",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3387111",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3387111",
  abstract =     "Open source developers, particularly the elite
                 developers who own the administrative privileges for a
                 project, maintain a diverse portfolio of contributing
                 activities. They not only commit source code but also
                 exert significant efforts on other communicative,
                 organizational, and supportive activities. However,
                 almost all prior research focuses on specific
                 activities and fails to analyze elite developers
                 activities in a comprehensive way. To bridge this gap,
                 we conduct an empirical study with fine-grained event
                 data from 20 large open source projects hosted on
                 GITHUB. We investigate elite developers contributing
                 activities and their impacts on project outcomes. Our
                 analyses reveal three key findings: (1) elite
                 developers participate in a variety of activities, of
                 which technical contributions (e.g., coding) only
                 account for a small proportion; (2) as the project
                 grows, elite developers tend to put more effort into
                 supportive and communicative activities and less effort
                 into coding; and (3) elite developers efforts in
                 nontechnical activities are negatively correlated with
                 the project's outcomes in terms of productivity and
                 quality in general, except for a positive correlation
                 with the bug fix rate (a quality indicator). These
                 results provide an integrated view of elite developers'
                 activities and can inform an individual's decision
                 making about effort allocation, which could lead to
                 improved project outcomes. The results also provide
                 implications for supporting these elite developers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Polyvyanyy:2020:MPR,
  author =       "Artem Polyvyanyy and Andreas Solti and Matthias
                 Weidlich and Claudio {Di Ciccio} and Jan Mendling",
  title =        "Monotone Precision and Recall Measures for Comparing
                 Executions and Specifications of Dynamic Systems",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "17:1--17:41",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3387909",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3387909",
  abstract =     "The behavioural comparison of systems is an important
                 concern of software engineering research. For example,
                 the areas of specification discovery and specification
                 mining are concerned with measuring the consistency
                 between a collection of execution \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Miranda:2020:TRU,
  author =       "Breno Miranda and Antonia Bertolino",
  title =        "Testing Relative to Usage Scope: Revisiting Software
                 Coverage Criteria",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "18:1--18:24",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3389126",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3389126",
  abstract =     "Coverage criteria provide a useful and widely used
                 means to guide software testing; however,
                 indiscriminately pursuing full coverage may not always
                 be convenient or meaningful, as not all entities are of
                 interest in any usage context. We aim at \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2020:WBU,
  author =       "Jieshan Chen and Chunyang Chen and Zhenchang Xing and
                 Xin Xia and Liming Zhu and John Grundy and Jinshui
                 Wang",
  title =        "Wireframe-based {UI} Design Search through Image
                 Autoencoder",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "19:1--19:31",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3391613",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3391613",
  abstract =     "UI design is an integral part of software development.
                 For many developers who do not have much UI design
                 experience, exposing them to a large database of
                 real-application UI designs can help them quickly build
                 up a realistic understanding of the design \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xue:2020:MOI,
  author =       "Yinxing Xue and Yan-Fu Li",
  title =        "Multi-objective Integer Programming Approaches for
                 Solving the Multi-criteria Test-suite Minimization
                 Problem: Towards Sound and Complete Solutions of a
                 Particular Search-based Software-engineering Problem",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "20:1--20:50",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3392031",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3392031",
  abstract =     "Test-suite minimization is one key technique for
                 optimizing the software testing process. Due to the
                 need to balance multiple factors, multi-criteria
                 test-suite minimization (MCTSM) becomes a popular
                 research topic in the recent decade. The MCTSM
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bao:2020:PDC,
  author =       "Lingfeng Bao and Zhenchang Xing and Xin Xia and David
                 Lo and Minghui Wu and Xiaohu Yang",
  title =        "{psc2code}: Denoising Code Extraction from Programming
                 Screencasts",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "3",
  pages =        "21:1--21:38",
  month =        jul,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3392093",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jul 10 13:50:17 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3392093",
  abstract =     "Programming screencasts have become a pervasive
                 resource on the Internet, which help developers learn
                 new programming technologies or skills. The source code
                 in programming screencasts is an important and valuable
                 information for developers. But the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arcuri:2020:HSD,
  author =       "Andrea Arcuri and Juan P. Galeotti",
  title =        "Handling {SQL} Databases in Automated System Test
                 Generation",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "22:1--22:31",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3391533",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3391533",
  abstract =     "Automated system test generation for web/enterprise
                 systems requires either a sequence of actions on a GUI
                 (e.g., clicking on HTML links and form buttons) or
                 direct HTTP calls when dealing with web services (e.g.,
                 REST and SOAP). When doing white-box. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pilgun:2020:FGC,
  author =       "Aleksandr Pilgun and Olga Gadyatskaya and Yury
                 Zhauniarovich and Stanislav Dashevskyi and Artsiom
                 Kushniarou and Sjouke Mauw",
  title =        "Fine-grained Code Coverage Measurement in Automated
                 Black-box {Android} Testing",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "23:1--23:35",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3395042",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3395042",
  abstract =     "Today, there are millions of third-party Android
                 applications. Some of them are buggy or even malicious.
                 To identify such applications, novel frameworks for
                 automated black-box testing and dynamic analysis are
                 being developed by the Android community. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2020:IIC,
  author =       "Junjie Wang and Ye Yang and Tim Menzies and Qing
                 Wang",
  title =        "{iSENSE2.0}: Improving Completion-aware Crowdtesting
                 Management with Duplicate Tagger and Sanity Checker",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "24:1--24:27",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3394602",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3394602",
  abstract =     "Software engineers get questions of ``how much testing
                 is enough'' on a regular basis. Existing approaches in
                 software testing management employ experience-, risk-,
                 or value-based analysis to prioritize and manage
                 testing processes. However, very few is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2020:MTC,
  author =       "Xihui Zhang and Thomas F. Stafford and Tao Hu and Hua
                 Dai",
  title =        "Measuring Task Conflict and Person Conflict in
                 Software Testing",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "25:1--25:19",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3395029",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3395029",
  abstract =     "Task-related conflict and person-related conflict in
                 software testing are inevitable and can impact the
                 effectiveness and efficiency of the software
                 development process. The dimensionality of conflict in
                 software testing is reasonably well understood,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2020:GQT,
  author =       "Zhipeng Gao and Xin Xia and John Grundy and David Lo
                 and Yuan-Fang Li",
  title =        "Generating Question Titles for {Stack Overflow} from
                 Mined Code Snippets",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "26:1--26:37",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3401026",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3401026",
  abstract =     "Stack Overflow has been heavily used by software
                 developers as a popular way to seek programming-related
                 information from peers via the internet. The Stack
                 Overflow community recommends users to provide the
                 related code snippet when they are creating a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yu:2020:SCR,
  author =       "Xiao Liang Yu and Omar Al-Bataineh and David Lo and
                 Abhik Roychoudhury",
  title =        "Smart Contract Repair",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "27:1--27:32",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3402450",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3402450",
  abstract =     "Smart contracts are automated or self-enforcing
                 contracts that can be used to exchange assets without
                 having to place trust in third parties. Many commercial
                 transactions use smart contracts due to their potential
                 benefits in terms of secure peer-to-. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Holmes:2020:URL,
  author =       "Josie Holmes and Iftekhar Ahmed and Caius Brindescu
                 and Rahul Gopinath and He Zhang and Alex Groce",
  title =        "Using Relative Lines of Code to Guide Automated Test
                 Generation for {Python}",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "28:1--28:38",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3408896",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3408896",
  abstract =     "Raw lines of code (LOC) is a metric that does not, at
                 first glance, seem extremely useful for automated test
                 generation. It is both highly language-dependent and
                 not extremely meaningful, semantically, within a
                 language: one coder can produce the same effect with
                 many fewer lines than another. However, relative LOC,
                 between components of the same project, turns out to be
                 a highly useful metric for automated testing. In this
                 article, we make use of a heuristic based on LOC counts
                 for tested functions to dramatically improve the
                 effectiveness of automated test generation. This
                 approach is particularly valuable in languages where
                 collecting code coverage data to guide testing has a
                 very high overhead. We apply the heuristic to
                 property-based Python testing using the TSTL (Template
                 Scripting Testing Language) tool. In our experiments,
                 the simple LOC heuristic can improve branch and
                 statement coverage by large margins (often more than
                 20\%, up to 40\% or more) and improve fault detection
                 by an even larger margin (usually more than 75\% and up
                 to 400\% or more). The LOC heuristic is also easy to
                 combine with other approaches and is comparable to, and
                 possibly more effective than, two well-established
                 approaches for guiding random testing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pantiuchina:2020:WDR,
  author =       "Jevgenija Pantiuchina and Fiorella Zampetti and Simone
                 Scalabrino and Valentina Piantadosi and Rocco Oliveto
                 and Gabriele Bavota and Massimiliano {Di Penta}",
  title =        "Why Developers Refactor Source Code: a Mining-based
                 Study",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "29:1--29:30",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3408302",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3408302",
  abstract =     "Refactoring aims at improving code non-functional
                 attributes without modifying its external behavior.
                 Previous studies investigated the motivations behind
                 refactoring by surveying developers. With the aim of
                 generalizing and complementing their findings,.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2020:PAE,
  author =       "Junjie Chen and Zhuo Wu and Zan Wang and Hanmo You and
                 Lingming Zhang and Ming Yan",
  title =        "Practical Accuracy Estimation for Efficient Deep
                 Neural Network Testing",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "30:1--30:35",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3394112",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3394112",
  abstract =     "Deep neural network (DNN) has become increasingly
                 popular and DNN testing is very critical to guarantee
                 the correctness of DNN, i.e., the accuracy of DNN in
                 this work. However, DNN testing suffers from a serious
                 efficiency problem, i.e., it is costly to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2020:MTN,
  author =       "Wenhan Wang and Ge Li and Sijie Shen and Xin Xia and
                 Zhi Jin",
  title =        "Modular Tree Network for Source Code Representation
                 Learning",
  journal =      j-TOSEM,
  volume =       "29",
  number =       "4",
  pages =        "31:1--31:23",
  month =        oct,
  year =         "2020",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3409331",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Oct 8 07:18:41 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3409331",
  abstract =     "Learning representation for source code is a
                 foundation of many program analysis tasks. In recent
                 years, neural networks have already shown success in
                 this area, but most existing models did not make full
                 use of the unique structural information of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guerriero:2021:SMD,
  author =       "Michele Guerriero and Damian Andrew Tamburri and
                 Elisabetta {Di Nitto}",
  title =        "{StreamGen}: Model-driven Development of Distributed
                 Streaming Applications",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "1:1--1:30",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3408895",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3408895",
  abstract =     "Distributed streaming applications, i.e., applications
                 that process massive streams of data in a distributed
                 fashion, are becoming increasingly popular to tame the
                 velocity and the volume of Big Data. Nevertheless, the
                 widespread adoption of data-. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Siegmund:2021:MVH,
  author =       "Janet Siegmund and Norman Peitek and Sven Apel and
                 Norbert Siegmund",
  title =        "Mastering Variation in Human Studies: The Role of
                 Aggregation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "2:1--2:40",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3406544",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3406544",
  abstract =     "The human factor is prevalent in empirical software
                 engineering research. However, human studies often do
                 not use the full potential of analysis methods by
                 combining analysis of individual tasks and participants
                 with an analysis that aggregates results \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rahman:2021:SSA,
  author =       "Akond Rahman and Md Rayhanur Rahman and Chris Parnin
                 and Laurie Williams",
  title =        "Security Smells in {Ansible} and {Chef} Scripts: a
                 Replication Study",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "3:1--3:31",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3408897",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3408897",
  abstract =     "Context: Security smells are recurring coding patterns
                 that are indicative of security weakness and require
                 further inspection. As infrastructure as code (IaC)
                 scripts, such as Ansible and Chef scripts, are used to
                 provision cloud-based servers and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2021:UWR,
  author =       "Huihui Zhang and Man Zhang and Tao Yue and Shaukat Ali
                 and Yan Li",
  title =        "Uncertainty-wise Requirements Prioritization with
                 Search",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "4:1--4:54",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3408301",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3408301",
  abstract =     "Requirements review is an effective technique to
                 ensure the quality of requirements in practice,
                 especially in safety-critical domains (e.g., avionics
                 systems, automotive systems). In such contexts, a
                 typical requirements review process often \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Al-Sibahi:2021:VPT,
  author =       "Ahmad Salim Al-Sibahi and Thomas P. Jensen and
                 Aleksandar S. Dimovski and Andrzej Wasowski",
  title =        "Verification of Program Transformations with Inductive
                 Refinement Types",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "5:1--5:33",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3409805",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3409805",
  abstract =     "High-level transformation languages like Rascal
                 include expressive features for manipulating large
                 abstract syntax trees: first-class traversals,
                 expressive pattern matching, backtracking, and
                 generalized iterators. We present the design and
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shariffdeen:2021:APT,
  author =       "Ridwan Salihin Shariffdeen and Shin Hwei Tan and
                 Mingyuan Gao and Abhik Roychoudhury",
  title =        "Automated Patch Transplantation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "6:1--6:36",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3412376",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3412376",
  abstract =     "Automated program repair is an emerging area that
                 attempts to patch software errors and vulnerabilities.
                 In this article, we formulate and study a problem
                 related to automated repair, namely automated patch
                 transplantation. A patch for an error in a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ma:2021:RTB,
  author =       "Xiaoxue Ma and Shangru Wu and Ernest Pobee and Xiupei
                 Mei and Hao Zhang and Bo Jiang and Wing-Kwong Chan",
  title =        "{RegionTrack}: a Trace-Based Sound and Complete
                 Checker to Debug Transactional Atomicity Violations and
                 Non-Serializable Traces",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "7:1--7:49",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3412377",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3412377",
  abstract =     "Atomicity is a correctness criterion to reason about
                 isolated code regions in a multithreaded program when
                 they are executed concurrently. However, dynamic
                 instances of these code regions, called transactions,
                 may fail to behave atomically, resulting in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ehsan:2021:ESD,
  author =       "Osama Ehsan and Safwat Hassan and Mariam {El Mezouar}
                 and Ying Zou",
  title =        "An Empirical Study of Developer Discussions in the
                 {Gitter} Platform",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "8:1--8:39",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3412378",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3412378",
  abstract =     "Developer chatrooms (e.g., the Gitter platform) are
                 gaining popularity as a communication channel among
                 developers. In developer chatrooms, a developer ( asker
                 ) posts questions and other developers ( respondents )
                 respond to the posted questions. The \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bagnara:2021:PAV,
  author =       "Roberto Bagnara and Michele Chiari and Roberta Gori
                 and Abramo Bagnara",
  title =        "A Practical Approach to Verification of Floating-Point
                 {C\slash C++} Programs with {\tt math.h}\slash {\tt
                 cmath} Functions",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "9:1--9:53",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3410875",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3410875",
  abstract =     "Verification of C/C++ programs has seen considerable
                 progress in several areas, but not for programs that
                 use these languages' mathematical libraries. The reason
                 is that all libraries in widespread use come with no
                 guarantees about the computed results. This would seem
                 to prevent any attempt at formal verification of
                 programs that use them: without a specification for the
                 functions, no conclusion can be drawn statically about
                 the behavior of the program. We propose an alternative
                 to surrender. We introduce a pragmatic approach that
                 leverages the fact that most {\tt math.h}\slash {\tt
                 cmath} functions are almost piecewise monotonic: as we
                 discovered through exhaustive testing, they may have
                 glitches, often of very small size and in small
                 numbers. We develop interval refinement techniques for
                 such functions based on a modified dichotomic search,
                 which enable verification via symbolic execution based
                 model checking, abstract interpretation, and test data
                 generation. To the best of our knowledge, our
                 refinement algorithms are the first in the literature
                 to be able to handle non-correctly rounded function
                 implementations, enabling verification in the presence
                 of the most common implementations. We experimentally
                 evaluate our approach on real-world code, showing its
                 ability to detect or rule out anomalous behaviors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fu:2021:SSC,
  author =       "Xiaoqin Fu and Haipeng Cai and Wen Li and Li Li",
  title =        "{SEADS}: Scalable and Cost-effective Dynamic
                 Dependence Analysis of Distributed Systems via
                 Reinforcement Learning",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "10:1--10:45",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3379345",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3379345",
  abstract =     "Distributed software systems are increasingly
                 developed and deployed today. Many of these systems are
                 supposed to run continuously. Given their critical
                 roles in our society and daily lives, assuring the
                 quality of distributed systems is crucial. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2021:TQS,
  author =       "Zhipeng Gao and Xin Xia and David Lo and John Grundy",
  title =        "Technical {Q8A} Site Answer Recommendation via
                 Question Boosting",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "1",
  pages =        "11:1--11:34",
  month =        jan,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3412845",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 22 07:02:14 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3412845",
  abstract =     "Software developers have heavily used online
                 question-and-answer platforms to seek help to solve
                 their technical problems. However, a major problem with
                 these technical Q8A sites is ``answer hungriness,''
                 i.e., a large number of questions remain \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Godoy:2021:EBT,
  author =       "Javier Godoy and Juan Pablo Galeotti and Diego
                 Garbervetsky and Sebasti{\'a}n Uchitel",
  title =        "Enabledness-based Testing of Object Protocols",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "12:1--12:36",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3415153",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3415153",
  abstract =     "A significant proportion of classes in modern software
                 introduce or use object protocols, prescriptions on the
                 temporal orderings of method calls on objects. This
                 article studies search-based test generation techniques
                 that aim to exploit a particular \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ma:2021:TSD,
  author =       "Wei Ma and Mike Papadakis and Anestis Tsakmalis and
                 Maxime Cordy and Yves Le Traon",
  title =        "Test Selection for Deep Learning Systems",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "13:1--13:22",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3417330",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3417330",
  abstract =     "Testing of deep learning models is challenging due to
                 the excessive number and complexity of the computations
                 involved. As a result, test data selection is performed
                 manually and in an ad hoc way. This raises the question
                 of how we can automatically \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2021:BTP,
  author =       "Xiang Gao and Bo Wang and Gregory J. Duck and Ruyi Ji
                 and Yingfei Xiong and Abhik Roychoudhury",
  title =        "Beyond Tests: Program Vulnerability Repair via Crash
                 Constraint Extraction",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "14:1--14:27",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3418461",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3418461",
  abstract =     "Automated program repair is an emerging technology
                 that seeks to automatically rectify program errors and
                 vulnerabilities. Repair techniques are driven by a
                 correctness criterion that is often in the form of a
                 test suite. Such test-based repair may \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ohrndorf:2021:HBM,
  author =       "Manuel Ohrndorf and Christopher Pietsch and Udo Kelter
                 and Lars Grunske and Timo Kehrer",
  title =        "History-based Model Repair Recommendations",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "15:1--15:46",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3419017",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3419017",
  abstract =     "Models in Model-driven Engineering are primary
                 development artifacts that are heavily edited in all
                 stages of software development and that can become
                 temporarily inconsistent during editing. In general,
                 there are many alternatives to resolve an \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kang:2021:ASM,
  author =       "Hong Jin Kang and David Lo",
  title =        "Adversarial Specification Mining",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "16:1--16:40",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3424307",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3424307",
  abstract =     "There have been numerous studies on mining temporal
                 specifications from execution traces. These approaches
                 learn finite-state automata (FSA) from execution traces
                 when running tests. To learn accurate specifications of
                 a software system, many tests are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gong:2021:TDG,
  author =       "Dunwei Gong and Baicai Sun and Xiangjuan Yao and Tian
                 Tian",
  title =        "Test Data Generation for Path Coverage of {MPI}
                 Programs Using {SAEO}",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "17:1--17:37",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3423132",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3423132",
  abstract =     "Message-passing interface (MPI) programs, a typical
                 kind of parallel programs, have been commonly used in
                 various applications. However, it generally takes
                 exhaustive computation to run these programs when
                 generating test data to test them. In this \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2021:EPS,
  author =       "Zhenpeng Chen and Yanbin Cao and Huihan Yao and Xuan
                 Lu and Xin Peng and Hong Mei and Xuanzhe Liu",
  title =        "Emoji-powered Sentiment and Emotion Detection from
                 Software Developers' Communication Data",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "18:1--18:48",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3424308",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3424308",
  abstract =     "Sentiment and emotion detection from textual
                 communication records of developers have various
                 application scenarios in software engineering (SE).
                 However, commonly used off-the-shelf sentiment/emotion
                 detection tools cannot obtain reliable results in SE
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chekam:2021:KSM,
  author =       "Thierry Titcheu Chekam and Mike Papadakis and Maxime
                 Cordy and Yves Le Traon",
  title =        "Killing Stubborn Mutants with Symbolic Execution",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "19:1--19:23",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3425497",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3425497",
  abstract =     "We introduce SEMu, a Dynamic Symbolic Execution
                 technique that generates test inputs capable of killing
                 stubborn mutants (killable mutants that remain
                 undetected after a reasonable amount of testing). SEMu
                 aims at mutant propagation (triggering \ldots{}).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ore:2021:EST,
  author =       "John-Paul Ore and Carrick Detweiler and Sebastian
                 Elbaum",
  title =        "An Empirical Study on Type Annotations: Accuracy,
                 Speed, and Suggestion Effectiveness",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "20:1--20:29",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3439775",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3439775",
  abstract =     "Type annotations connect variables to domain-specific
                 types. They enable the power of type checking and can
                 detect faults early. In practice, type annotations have
                 a reputation of being burdensome to developers. We
                 lack, however, an empirical \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2021:WAA,
  author =       "Bozhi Wu and Sen Chen and Cuiyun Gao and Lingling Fan
                 and Yang Liu and Weiping Wen and Michael R. Lyu",
  title =        "Why an {Android} App Is Classified as Malware: Toward
                 Malware Classification Interpretation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "21:1--21:29",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3423096",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3423096",
  abstract =     "Machine learning-(ML) based approach is considered as
                 one of the most promising techniques for Android
                 malware detection and has achieved high accuracy by
                 leveraging commonly used features. In practice, most of
                 the ML classifications only provide a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2021:CSO,
  author =       "Haoxiang Zhang and Shaowei Wang and Tse-Hsun (Peter)
                 Chen and Ahmed E. Hassan",
  title =        "Are Comments on {Stack Overflow} Well Organized for
                 Easy Retrieval by Developers?",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "22:1--22:31",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3434279",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3434279",
  abstract =     "Many Stack Overflow answers have associated
                 informative comments that can strengthen them and
                 assist developers. A prior study found that comments
                 can provide additional information to point out issues
                 in their associated answer, such as the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zou:2021:IDL,
  author =       "Deqing Zou and Yawei Zhu and Shouhuai Xu and Zhen Li
                 and Hai Jin and Hengkai Ye",
  title =        "Interpreting Deep Learning-based Vulnerability
                 Detector Predictions Based on Heuristic Searching",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "23:1--23:31",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3429444",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3429444",
  abstract =     "Detecting software vulnerabilities is an important
                 problem and a recent development in tackling the
                 problem is the use of deep learning models to detect
                 software vulnerabilities. While effective, it is hard
                 to explain why a deep learning model predicts
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Vandehei:2021:LDL,
  author =       "Bailey Vandehei and Daniel Alencar Da Costa and Davide
                 Falessi",
  title =        "Leveraging the Defects Life Cycle to Label Affected
                 Versions and Defective Classes",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "24:1--24:35",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3433928",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3433928",
  abstract =     "Two recent studies explicitly recommend labeling
                 defective classes in releases using the affected
                 versions (AV) available in issue trackers (e.g., Jira).
                 This practice is coined as the realistic approach.
                 However, no study has investigated whether it is
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2021:WMC,
  author =       "Qiuyuan Chen and Xin Xia and Han Hu and David Lo and
                 Shanping Li",
  title =        "Why My Code Summarization Model Does Not Work: Code
                 Comment Improvement with Category Prediction",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "2",
  pages =        "25:1--25:29",
  month =        mar,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3434280",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Thu Mar 18 06:18:01 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3434280",
  abstract =     "Code summarization aims at generating a code comment
                 given a block of source code and it is normally
                 performed by training machine learning algorithms on
                 existing code block-comment pairs. Code comments in
                 practice have different intentions. For example,.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2021:E,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "26e:1--26e:1",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3450737",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450737",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2021:HAF,
  author =       "Pengfei Gao and Hongyi Xie and Fu Song and Taolue
                 Chen",
  title =        "A Hybrid Approach to Formal Verification of
                 Higher-Order Masked Arithmetic Programs",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "26:1--26:42",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3428015",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3428015",
  abstract =     "Side-channel attacks, which are capable of breaking
                 secrecy via side-channel information, pose a growing
                 threat to the implementation of cryptographic
                 algorithms. Masking is an effective countermeasure
                 against side-channel attacks by removing the
                 statistical dependence between secrecy and power
                 consumption via randomization. However, designing
                 efficient and effective masked implementations turns
                 out to be an error-prone task. Current techniques for
                 verifying whether masked programs are secure are
                 limited in their applicability and accuracy, especially
                 when they are applied. To bridge this gap, in this
                 article, we first propose a sound type system, equipped
                 with an efficient type inference algorithm, for
                 verifying masked arithmetic programs against
                 higher-order attacks. We then give novel
                 model-counting-based and pattern-matching-based methods
                 that are able to precisely determine whether the
                 potential leaky observable sets detected by the type
                 system are genuine or simply spurious. We evaluate our
                 approach on various implementations of arithmetic
                 cryptographic programs. The experiments confirm that
                 our approach outperforms the state-of-the-art baselines
                 in terms of applicability, accuracy, and efficiency.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lara:2021:FOM,
  author =       "Juan {De Lara} and Esther Guerra and J{\"o}rg
                 Kienzle",
  title =        "Facet-oriented Modelling",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "27:1--27:59",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3428076",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3428076",
  abstract =     "Models are the central assets in model-driven
                 engineering (MDE), as they are actively used in all
                 phases of software development. Models are built using
                 metamodel-based languages, and so objects in models are
                 typed by a metamodel class. This typing is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zarir:2021:DCE,
  author =       "Abdullah A. Zarir and Gustavo A. Oliva and Zhen M.
                 (Jack) Jiang and Ahmed E. Hassan",
  title =        "Developing Cost-Effective Blockchain-Powered
                 Applications: a Case Study of the Gas Usage of Smart
                 Contract Transactions in the {Ethereum} Blockchain
                 Platform",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "28:1--28:38",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3431726",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3431726",
  abstract =     "Ethereum is a blockchain platform that hosts and
                 executes smart contracts. Executing a function of a
                 smart contract burns a certain amount of gas units
                 (a.k.a., gas usage). The total gas usage depends on how
                 much computing power is necessary to carry \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Abidi:2021:MLD,
  author =       "Mouna Abidi and Md Saidur Rahman and Moses Openja and
                 Foutse Khomh",
  title =        "Are Multi-Language Design Smells Fault-Prone? {An}
                 Empirical Study",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "29:1--29:56",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3432690",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3432690",
  abstract =     "Nowadays, modern applications are developed using
                 components written in different programming languages
                 and technologies. The cost benefits of reuse and the
                 advantages of each programming language are two main
                 incentives behind the proliferation of such \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sharafi:2021:TOM,
  author =       "Zohreh Sharafi and Yu Huang and Kevin Leach and
                 Westley Weimer",
  title =        "Toward an Objective Measure of Developers' Cognitive
                 Activities",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "30:1--30:40",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3434643",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3434643",
  abstract =     "Understanding how developers carry out different
                 computer science activities with objective measures can
                 help to improve productivity and guide the use and
                 development of supporting tools in software
                 engineering. In this article, we present two \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Uddin:2021:AAU,
  author =       "Gias Uddin and Foutse Khomh and Chanchal K. Roy",
  title =        "Automatic {API} Usage Scenario Documentation from
                 Technical {Q\&A} Sites",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "31:1--31:45",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3439769",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3439769",
  abstract =     "The online technical Q\&A site Stack Overflow (SO) is
                 popular among developers to support their coding and
                 diverse development needs. To address shortcomings in
                 API official documentation resources, several research
                 works have thus focused on augmenting \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2021:TRE,
  author =       "Xiaoyu Sun and Li Li and Tegawend{\'e} F.
                 Bissyand{\'e} and Jacques Klein and Damien Octeau and
                 John Grundy",
  title =        "Taming Reflection: an Essential Step Toward
                 Whole-program Analysis of {Android} Apps",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "32:1--32:36",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3440033",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3440033",
  abstract =     "Android developers heavily use reflection in their
                 apps for legitimate reasons. However, reflection is
                 also significantly used for hiding malicious actions.
                 Unfortunately, current state-of-the-art static analysis
                 tools for Android are challenged by the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2021:PPA,
  author =       "Guoliang Zhao and Safwat Hassan and Ying Zou and Derek
                 Truong and Toby Corbin",
  title =        "Predicting Performance Anomalies in Software Systems
                 at Run-time",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "33:1--33:33",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3440757",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3440757",
  abstract =     "High performance is a critical factor to achieve and
                 maintain the success of a software system. Performance
                 anomalies represent the performance degradation issues
                 (e.g., slowing down in system response times) of
                 software systems at run-time. Performance \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Castro:2021:FFS,
  author =       "Thiago Castro and Leopoldo Teixeira and Vander Alves
                 and Sven Apel and Maxime Cordy and Rohit Gheyi",
  title =        "A Formal Framework of Software Product Line Analyses",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "34:1--34:37",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3442389",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3442389",
  abstract =     "A number of product-line analysis approaches lift
                 analyses such as type checking, model checking, and
                 theorem proving from the level of single programs to
                 the level of product lines. These approaches share
                 concepts and mechanisms that suggest an \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yanez:2021:AIT,
  author =       "Wendy Y{\'a}nez and Rami Bahsoon and Yuqun Zhang and
                 Rick Kazman",
  title =        "Architecting {Internet of Things} Systems with
                 Blockchain: a Catalog of Tactics",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "35:1--35:46",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3442412",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3442412",
  abstract =     "Blockchain offers a distributed ledger to record data
                 collected from Internet of Thing (IoT) devices as
                 immutable and tamper-proof transactions and securely
                 shared among authorized participants in a Peer-to-Peer
                 (P2P) network. Despite the growing \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Scalabrino:2021:ASB,
  author =       "Simone Scalabrino and Antonio Mastropaolo and Gabriele
                 Bavota and Rocco Oliveto",
  title =        "An Adaptive Search Budget Allocation Approach for
                 Search-Based Test Case Generation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "36:1--36:26",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3446199",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3446199",
  abstract =     "Search-based techniques have been successfully used to
                 automate test case generation. Such approaches allocate
                 a fixed search budget to generate test cases aiming at
                 maximizing code coverage. The search budget plays a
                 crucial role; due to the hugeness \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2021:HSI,
  author =       "Qiuyuan Chen and Chunyang Chen and Safwat Hassan and
                 Zhengchang Xing and Xin Xia and Ahmed E. Hassan",
  title =        "How Should {I} Improve the {UI} of My App?: a Study of
                 User Reviews of Popular Apps in the {Google Play}",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "37:1--37:38",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447808",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447808",
  abstract =     "UI (User Interface) is an essential factor influencing
                 users' perception of an app. However, it is hard for
                 even professional designers to determine if the UI is
                 good or not for end-users. Users' feedback (e.g., user
                 reviews in the Google Play) provides \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cheng:2021:DSD,
  author =       "Xiao Cheng and Haoyu Wang and Jiayi Hua and Guoai Xu
                 and Yulei Sui",
  title =        "{DeepWukong}: Statically Detecting Software
                 Vulnerabilities Using Deep Graph Neural Network",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "38:1--38:33",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3436877",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3436877",
  abstract =     "Static bug detection has shown its effectiveness in
                 detecting well-defined memory errors, e.g., memory
                 leaks, buffer overflows, and null dereference. However,
                 modern software systems have a wide variety of
                 vulnerabilities. These vulnerabilities are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zou:2021:IAM,
  author =       "Deqing Zou and Yueming Wu and Siru Yang and Anki
                 Chauhan and Wei Yang and Jiangying Zhong and Shihan Dou
                 and Hai Jin",
  title =        "{IntDroid}: {Android} Malware Detection Based on {API}
                 Intimacy Analysis",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "39:1--39:32",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3442588",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3442588",
  abstract =     "Android, the most popular mobile operating system, has
                 attracted millions of users around the world.
                 Meanwhile, the number of new Android malware instances
                 has grown exponentially in recent years. On the one
                 hand, existing Android malware detection \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "39",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2021:ISD,
  author =       "Yanjie Zhao and Li Li and Haoyu Wang and Haipeng Cai
                 and Tegawend{\'e} F. Bissyand{\'e} and Jacques Klein
                 and John Grundy",
  title =        "On the Impact of Sample Duplication in
                 Machine-Learning-Based {Android} Malware Detection",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "3",
  pages =        "40:1--40:38",
  month =        may,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3446905",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Sun May 9 12:13:25 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3446905",
  abstract =     "Malware detection at scale in the Android realm is
                 often carried out using machine learning techniques.
                 State-of-the-art approaches such as DREBIN and
                 MaMaDroid are reported to yield high detection rates
                 when assessed against well-known datasets. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "40",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2021:LCF,
  author =       "Jianhui Chen and Fei He",
  title =        "Leveraging Control Flow Knowledge in {SMT} Solving of
                 Program Verification",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "41:1--41:26",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3446211",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3446211",
  abstract =     "Satisfiability modulo theories (SMT) solvers have been
                 widely applied as the reasoning engine for diverse
                 software analysis and verification technologies. The
                 efficiency of the SMT solver has significant effects on
                 the performance of these technologies. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "41",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bogart:2021:WHM,
  author =       "Chris Bogart and Christian K{\"a}stner and James
                 Herbsleb and Ferdian Thung",
  title =        "When and How to Make Breaking Changes: Policies and
                 Practices in 18 Open Source Software Ecosystems",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "42:1--42:56",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447245",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447245",
  abstract =     "Open source software projects often rely on package
                 management systems that help projects discover,
                 incorporate, and maintain dependencies on other
                 packages, maintained by other people. Such systems save
                 a great deal of effort over ad hoc ways of advertising,
                 packaging, and transmitting useful libraries, but
                 coordination among project teams is still needed when
                 one package makes a breaking change affecting other
                 packages. Ecosystems differ in their approaches to
                 breaking changes, and there is no general theory to
                 explain the relationships between features, behavioral
                 norms, ecosystem outcomes, and motivating values. We
                 address this through two empirical studies. In an
                 interview case study, we contrast Eclipse, NPM, and
                 CRAN, demonstrating that these different norms for
                 coordination of breaking changes shift the costs of
                 using and maintaining the software among stakeholders,
                 appropriate to each ecosystem s mission. In a second
                 study, we combine a survey, repository mining, and
                 document analysis to broaden and systematize these
                 observations across 18 ecosystems. We find that all
                 ecosystems share values such as stability and
                 compatibility, but differ in other values. Ecosystems
                 practices often support their espoused values, but in
                 surprisingly diverse ways. The data provides
                 counterevidence against easy generalizations about why
                 ecosystem communities do what they do.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "42",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ferrando:2021:THA,
  author =       "Angelo Ferrando and Louise A. Dennis and Rafael C.
                 Cardoso and Michael Fisher and Davide Ancona and
                 Viviana Mascardi",
  title =        "Toward a Holistic Approach to Verification and
                 Validation of Autonomous Cognitive Systems",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "43:1--43:43",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447246",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447246",
  abstract =     "When applying formal verification to a system that
                 interacts with the real world, we must use a model of
                 the environment. This model represents an abstraction
                 of the actual environment, so it is necessarily
                 incomplete and hence presents an issue for \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "43",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Menendez:2021:DFT,
  author =       "H{\'e}ctor D. Men{\'e}ndez and Gunel Jahangirova and
                 Federica Sarro and Paolo Tonella and David Clark",
  title =        "Diversifying Focused Testing for Unit Testing",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "44:1--44:24",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447265",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447265",
  abstract =     "Software changes constantly, because developers add
                 new features or modifications. This directly affects
                 the effectiveness of the test suite associated with
                 that software, especially when these new modifications
                 are in a specific area that no test case \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "44",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2021:HFW,
  author =       "Zhaoqiang Guo and Shiran Liu and Jinping Liu and
                 Yanhui Li and Lin Chen and Hongmin Lu and Yuming Zhou",
  title =        "How Far Have We Progressed in Identifying
                 Self-admitted Technical Debts? {A} Comprehensive
                 Empirical Study",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "45:1--45:56",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447247",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447247",
  abstract =     "Background. Self-admitted technical debt (SATD) is a
                 special kind of technical debt that is intentionally
                 introduced and remarked by code comments. Those
                 technical debts reduce the quality of software and
                 increase the cost of subsequent software \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "45",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lu:2021:ECR,
  author =       "Jingbo Lu and Dongjie He and Jingling Xue",
  title =        "{Eagle}: {CFL}-Reachability-Based Precision-Preserving
                 Acceleration of Object-Sensitive Pointer Analysis with
                 Partial Context Sensitivity",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "46:1--46:46",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3450492",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450492",
  abstract =     "Object sensitivity is widely used as a context
                 abstraction for computing the points-to information
                 context-sensitively for object-oriented programming
                 languages such as Java. Due to the combinatorial
                 explosion of contexts in large object-oriented
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "46",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Paulweber:2021:SIT,
  author =       "Philipp Paulweber and Georg Simhandl and Uwe Zdun",
  title =        "Specifying with Interface and Trait Abstractions in
                 Abstract State Machines: a Controlled Experiment",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "47:1--47:29",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3450968",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450968",
  abstract =     "Abstract State Machine (ASM) theory is a well-known
                 state-based formal method. As in other state-based
                 formal methods, the proposed specification languages
                 for ASMs still lack easy-to-comprehend abstractions to
                 express structural and behavioral aspects \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "47",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chatterjee:2021:AIQ,
  author =       "Preetha Chatterjee and Kostadin Damevski and Nicholas
                 A. Kraft and Lori Pollock",
  title =        "Automatically Identifying the Quality of Developer
                 Chats for Post Hoc Use",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "48:1--48:28",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3450503",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450503",
  abstract =     "Software engineers are crowdsourcing answers to their
                 everyday challenges on Q\&A forums (e.g., Stack
                 Overflow) and more recently in public chat communities
                 such as Slack, IRC, and Gitter. Many software-related
                 chat conversations contain valuable expert \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "48",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tao:2021:SDM,
  author =       "Yida Tao and Shan Tang and Yepang Liu and Zhiwu Xu and
                 Shengchao Qin",
  title =        "Speeding Up Data Manipulation Tasks with Alternative
                 Implementations: an Exploratory Study",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "49:1--49:28",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3456873",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3456873",
  abstract =     "As data volume and complexity grow at an unprecedented
                 rate, the performance of data manipulation programs is
                 becoming a major concern for developers. In this
                 article, we study how alternative API choices could
                 improve data manipulation performance \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "49",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chondamrongkul:2021:SAM,
  author =       "Nacha Chondamrongkul and Jing Sun and Ian Warren",
  title =        "Software Architectural Migration: an Automated
                 Planning Approach",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "50:1--50:35",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3461011",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3461011",
  abstract =     "Software architectural designs are usually changed
                 over time to support emerging technologies and to
                 adhere to new principles. Architectural migration is an
                 important activity that helps to transform the
                 architectural styles applied during a system's
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "50",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sobhy:2021:ESA,
  author =       "Dalia Sobhy and Rami Bahsoon and Leandro Minku and
                 Rick Kazman",
  title =        "Evaluation of Software Architectures under
                 Uncertainty: a Systematic Literature Review",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "51:1--51:50",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464305",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464305",
  abstract =     "Context: Evaluating software architectures in
                 uncertain environments raises new challenges, which
                 require continuous approaches. We define continuous
                 evaluation as multiple evaluations of the software
                 architecture that begins at the early stages of the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "51",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Russo:2021:ASM,
  author =       "Daniel Russo",
  title =        "The Agile Success Model: a Mixed-methods Study of a
                 Large-scale Agile Transformation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "52:1--52:46",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464938",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464938",
  abstract =     "Organizations are increasingly adopting Agile
                 frameworks for their internal software development.
                 Cost reduction, rapid deployment, requirements and
                 mental model alignment are typical reasons for an Agile
                 transformation. This article presents an in-.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "52",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Safdar:2021:RFC,
  author =       "Safdar Aqeel Safdar and Tao Yue and Shaukat Ali",
  title =        "Recommending Faulty Configurations for Interacting
                 Systems Under Test Using Multi-objective Search",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "53:1--53:36",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464939",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464939",
  abstract =     "Modern systems, such as cyber-physical systems, often
                 consist of multiple products within/across product
                 lines communicating with each other through information
                 networks. Consequently, their runtime behaviors are
                 influenced by product configurations and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "53",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lyu:2021:ESI,
  author =       "Yingzhe Lyu and Heng Li and Mohammed Sayagh and Zhen
                 Ming (Jack) Jiang and Ahmed E. Hassan",
  title =        "An Empirical Study of the Impact of Data Splitting
                 Decisions on the Performance of {AIOps} Solutions",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "54:1--54:38",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3447876",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3447876",
  abstract =     "AIOps (Artificial Intelligence for IT Operations)
                 leverages machine learning models to help practitioners
                 handle the massive data produced during the operations
                 of large-scale systems. However, due to the nature of
                 the operation data, AIOps modeling \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "54",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dilhara:2021:USS,
  author =       "Malinda Dilhara and Ameya Ketkar and Danny Dig",
  title =        "Understanding {Software-2.0}: a Study of Machine
                 Learning Library Usage and Evolution",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "55:1--55:42",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3453478",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3453478",
  abstract =     "Enabled by a rich ecosystem of Machine Learning (ML)
                 libraries, programming using learned models, i.e.,
                 Software-2.0, has gained substantial adoption. However,
                 we do not know what challenges developers encounter
                 when they use ML libraries. With this \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "55",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2021:CAR,
  author =       "Haoye Wang and Xin Xia and David Lo and Qiang He and
                 Xinyu Wang and John Grundy",
  title =        "Context-aware Retrieval-based Deep Commit Message
                 Generation",
  journal =      j-TOSEM,
  volume =       "30",
  number =       "4",
  pages =        "56:1--56:30",
  month =        jul,
  year =         "2021",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464689",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Aug 4 07:53:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464689",
  abstract =     "Commit messages recorded in version control systems
                 contain valuable information for software development,
                 maintenance, and comprehension. Unfortunately,
                 developers often commit code with empty or poor quality
                 commit messages. To address this issue, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "56",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arcuri:2022:ESB,
  author =       "Andrea Arcuri and Juan P. Galeotti",
  title =        "Enhancing Search-based Testing with Testability
                 Transformations for Existing {APIs}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "1:1--1:34",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3477271",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477271",
  abstract =     "Search-based software testing (SBST) has been shown to
                 be an effective technique to generate test cases
                 automatically. Its effectiveness strongly depends on
                 the guidance of the fitness function. Unfortunately, a
                 common issue in SBST is the so-called flag \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2022:AHS,
  author =       "Man Zhang and Andrea Arcuri",
  title =        "Adaptive Hypermutation for Search-Based System Test
                 Generation: a Study on {REST APIs} with {EvoMaster}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "2:1--2:52",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464940",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464940",
  abstract =     "REST web services are widely popular in industry, and
                 search techniques have been successfully used to
                 automatically generate system-level test cases for
                 those systems. In this article, we propose a novel
                 mutation operator which is designed specifically
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2022:MSC,
  author =       "Hui Xu and Zhuangbin Chen and Mingshen Sun and Yangfan
                 Zhou and Michael R. Lyu",
  title =        "Memory-Safety Challenge Considered Solved? {An}
                 In-Depth Study with All {Rust} {CVEs}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "3:1--3:25",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3466642",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3466642",
  abstract =     "Rust is an emerging programming language that aims at
                 preventing memory-safety bugs without sacrificing much
                 efficiency. The claimed property is very attractive to
                 developers, and many projects start using the language.
                 However, can Rust achieve the memory-safety promise?
                 This article studies the question by surveying 186
                 real-world bug reports collected from several origins,
                 which contain all existing Rust common vulnerability
                 and exposures (CVEs) of memory-safety issues by
                 2020-12-31. We manually analyze each bug and extract
                 their culprit patterns. Our analysis result shows that
                 Rust can keep its promise that all memory-safety bugs
                 require unsafe code, and many memory-safety bugs in our
                 dataset are mild soundness issues that only leave a
                 possibility to write memory-safety bugs without unsafe
                 code. Furthermore, we summarize three typical
                 categories of memory-safety bugs, including automatic
                 memory reclaim, unsound function, and unsound generic
                 or trait. While automatic memory claim bugs are related
                 to the side effect of Rust newly-adopted
                 ownership-based resource management scheme, unsound
                 function reveals the essential challenge of Rust
                 development for avoiding unsound code, and unsound
                 generic or trait intensifies the risk of introducing
                 unsoundness. Based on these findings, we propose two
                 promising directions toward improving the security of
                 Rust development, including several best practices of
                 using specific APIs and methods to detect particular
                 bugs involving unsafe code. Our work intends to raise
                 more discussions regarding the memory-safety issues of
                 Rust and facilitate the maturity of the language.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Falessi:2022:IDD,
  author =       "Davide Falessi and Aalok Ahluwalia and Massimiliano DI
                 Penta",
  title =        "The Impact of Dormant Defects on Defect Prediction: a
                 Study of 19 {Apache} Projects",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "4:1--4:26",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3467895",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3467895",
  abstract =     "Defect prediction models can be beneficial to
                 prioritize testing, analysis, or code review
                 activities, and has been the subject of a substantial
                 effort in academia, and some applications in industrial
                 contexts. A necessary precondition when creating a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Vogel-Heuser:2022:MIA,
  author =       "Birgit Vogel-Heuser and Eva-Maria Neumann and Juliane
                 Fischer",
  title =        "{MICOSE4aPS}: Industrially Applicable Maturity Metric
                 to Improve Systematic Reuse of Control Software",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "5:1--5:24",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3467896",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3467896",
  abstract =     "automated Production Systems (aPS) are highly complex,
                 mechatronic systems that usually have to operate
                 reliably for many decades. Standardization and reuse of
                 control software modules is a core prerequisite to
                 achieve the required system quality in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sundelin:2022:TAS,
  author =       "Anders Sundelin and Javier Gonzalez-huerta and
                 Krzysztof Wnuk and Tony Gorschek",
  title =        "Towards an Anatomy of Software Craftsmanship",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "6:1--6:49",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3468504",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3468504",
  abstract =     "Context: The concept of software craftsmanship has
                 early roots in computing, and in 2009, the Manifesto
                 for Software Craftsmanship was formulated as a reaction
                 to how the Agile methods were practiced and taught. But
                 software craftsmanship has seldom been \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Graziotin:2022:PBS,
  author =       "Daniel Graziotin and Per Lenberg and Robert Feldt and
                 Stefan Wagner",
  title =        "Psychometrics in Behavioral Software Engineering: a
                 Methodological Introduction with Guidelines",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "7:1--7:36",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3469888",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3469888",
  abstract =     "A meaningful and deep understanding of the human
                 aspects of software engineering (SE) requires
                 psychological constructs to be considered. Psychology
                 theory can facilitate the systematic and sound
                 development as well as the adoption of instruments
                 \ldots{}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2022:PTP,
  author =       "Jianyi Zhou and Junjie Chen and Dan Hao",
  title =        "Parallel Test Prioritization",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "8:1--8:50",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3471906",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3471906",
  abstract =     "Although regression testing is important to guarantee
                 the software quality in software evolution, it suffers
                 from the widely known cost problem. To address this
                 problem, existing researchers made dedicated efforts on
                 test prioritization, which optimizes \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rauf:2022:CAS,
  author =       "Irum Rauf and Marian Petre and Thein Tun and Tamara
                 Lopez and Paul Lunn and Dirk {Van Der Linden} and John
                 Towse and Helen Sharp and Mark Levine and Awais Rashid
                 and Bashar Nuseibeh",
  title =        "The Case for Adaptive Security Interventions",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "9:1--9:52",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3471930",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3471930",
  abstract =     "Despite the availability of various methods and tools
                 to facilitate secure coding, developers continue to
                 write code that contains common vulnerabilities. It is
                 important to understand why technological advances do
                 not sufficiently facilitate developers \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arcega:2022:BLM,
  author =       "Lorena Arcega and Jaime Font and {\O}ystein Haugen and
                 Carlos Cetina",
  title =        "Bug Localization in Model-Based Systems in the Wild",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "10:1--10:32",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3472616",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3472616",
  abstract =     "The companies that have adopted the Model-Driven
                 Engineering (MDE) paradigm have the advantage of
                 working at a high level of abstraction. Nevertheless,
                 they have the disadvantage of the lack of tools
                 available to perform bug localization at the model
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2022:AAR,
  author =       "Cuiyun Gao and Wenjie Zhou and Xin Xia and David Lo
                 and Qi Xie and Michael R. Lyu",
  title =        "Automating App Review Response Generation Based on
                 Contextual Knowledge",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "11:1--11:36",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3464969",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3464969",
  abstract =     "User experience of mobile apps is an essential
                 ingredient that can influence the user base and app
                 revenue. To ensure good user experience and assist app
                 development, several prior studies resort to analysis
                 of app reviews, a type of repository that \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2022:CSC,
  author =       "Chao Liu and Xin Xia and David Lo and Zhiwe Liu and
                 Ahmed E. Hassan and Shanping Li",
  title =        "{CodeMatcher}: Searching Code Based on Sequential
                 Semantics of Important Query Words",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "12:1--12:37",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3465403",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3465403",
  abstract =     "To accelerate software development, developers
                 frequently search and reuse existing code snippets from
                 a large-scale codebase, e.g., GitHub. Over the years,
                 researchers proposed many information retrieval
                 (IR)-based models for code search, but they fail
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2022:SAI,
  author =       "Yaqin Zhou and Jing Kai Siow and Chenyu Wang and
                 Shangqing Liu and Yang Liu",
  title =        "{SPI}: Automated Identification of Security Patches
                 via Commits",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "13:1--13:27",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3468854",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3468854",
  abstract =     "Security patches in open source software, providing
                 security fixes to identified vulnerabilities, are
                 crucial in protecting against cyber attacks. Security
                 advisories and announcements are often publicly
                 released to inform the users about potential \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nikanjam:2022:AFD,
  author =       "Amin Nikanjam and Houssem {Ben Braiek} and Mohammad
                 Mehdi Morovati and Foutse Khomh",
  title =        "Automatic Fault Detection for Deep Learning Programs
                 Using Graph Transformations",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "14:1--14:27",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3470006",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3470006",
  abstract =     "Nowadays, we are witnessing an increasing demand in
                 both corporates and academia for exploiting Deep
                 Learning (DL) to solve complex real-world problems. A
                 DL program encodes the network structure of a desirable
                 DL model and the process by which the model \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2022:RRD,
  author =       "Chao Liu and Cuiyun Gao and Xin Xia and David Lo and
                 John Grundy and Xiaohu Yang",
  title =        "On the Reproducibility and Replicability of Deep
                 Learning in Software Engineering",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "15:1--15:46",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3477535",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477535",
  abstract =     "Context: Deep learning (DL) techniques have gained
                 significant popularity among software engineering (SE)
                 researchers in recent years. This is because they can
                 often solve many SE challenges without enormous manual
                 feature engineering effort and complex \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lyu:2022:TCI,
  author =       "Yingzhe Lyu and Gopi Krishnan Rajbahadur and Dayi Lin
                 and Boyuan Chen and Zhen Ming (Jack) Jiang",
  title =        "Towards a Consistent Interpretation of {AIOps}
                 Models",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "16:1--16:38",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3488269",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3488269",
  abstract =     "Artificial Intelligence for IT Operations (AIOps) has
                 been adopted in organizations in various tasks,
                 including interpreting models to identify indicators of
                 service failures. To avoid misleading practitioners,
                 AIOps model interpretations should be \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Parry:2022:SFT,
  author =       "Owain Parry and Gregory M. Kapfhammer and Michael
                 Hilton and Phil McMinn",
  title =        "A Survey of Flaky Tests",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "1",
  pages =        "17:1--17:74",
  month =        jan,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3476105",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jan 7 07:51:00 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3476105",
  abstract =     "Tests that fail inconsistently, without changes to the
                 code under test, are described as flaky. Flaky tests do
                 not give a clear indication of the presence of software
                 bugs and thus limit the reliability of the test suites
                 that contain them. A recent \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2022:ERP,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial: a Retrospective and Prospective
                 Reflection",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "18e:1--18e:2",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3523278",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3523278",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lano:2022:MTD,
  author =       "K. Lano and S. Kolahdouz-Rahimi and S. Fang",
  title =        "Model Transformation Development Using Automated
                 Requirements Analysis, Metamodel Matching, and
                 Transformation by Example",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "18:1--18:71",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3471907",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3471907",
  abstract =     "In this article, we address how the production of
                 model transformations (MT) can be accelerated by
                 automation of transformation synthesis from
                 requirements, examples, and metamodels. We introduce a
                 synthesis process based on metamodel matching,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bock:2022:MMG,
  author =       "Thomas Bock and Angelika Schmid and Sven Apel",
  title =        "Measuring and Modeling Group Dynamics in Open-Source
                 Software Development: a Tensor Decomposition Approach",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "19:1--19:50",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3473139",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3473139",
  abstract =     "Many open-source software projects depend on a few
                 core developers, who take over both the bulk of
                 coordination and programming tasks. They are supported
                 by peripheral developers, who contribute either via
                 discussions or programming tasks, often for a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ebrahimi:2022:CMA,
  author =       "Fahimeh Ebrahimi and Miroslav Tushev and Anas
                 Mahmoud",
  title =        "Classifying Mobile Applications Using Word
                 Embeddings",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "20:1--20:30",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3474827",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3474827",
  abstract =     "Modern application stores enable developers to
                 classify their apps by choosing from a set of generic
                 categories, or genres, such as health, games, and
                 music. These categories are typically static-new
                 categories do not necessarily emerge over time to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ardito:2022:FMB,
  author =       "Luca Ardito and Andrea Bottino and Riccardo Coppola
                 and Fabrizio Lamberti and Francesco Manigrasso and Lia
                 Morra and Marco Torchiano",
  title =        "Feature Matching-based Approaches to Improve the
                 Robustness of {Android} Visual {GUI} Testing",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "21:1--21:32",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3477427",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477427",
  abstract =     "In automated Visual GUI Testing (VGT) for Android
                 devices, the available tools often suffer from low
                 robustness to mobile fragmentation, leading to
                 incorrect results when running the same tests on
                 different devices. To soften these issues, we evaluate
                 two \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Maddila:2022:CCE,
  author =       "Chandra Maddila and Nachiappan Nagappan and Christian
                 Bird and Georgios Gousios and Arie van Deursen",
  title =        "{ConE}: a Concurrent Edit Detection Tool for
                 Large-scale Software Development",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "22:1--22:26",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3478019",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3478019",
  abstract =     "Modern, complex software systems are being
                 continuously extended and adjusted. The developers
                 responsible for this may come from different teams or
                 organizations, and may be distributed over the world.
                 This may make it difficult to keep track of what
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pantiuchina:2022:WDD,
  author =       "Jevgenija Pantiuchina and Bin Lin and Fiorella
                 Zampetti and Massimiliano {Di Penta} and Michele Lanza
                 and Gabriele Bavota",
  title =        "Why Do Developers Reject Refactorings in Open-Source
                 Projects?",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "23:1--23:23",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487062",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487062",
  abstract =     "Refactoring operations are behavior-preserving changes
                 aimed at improving source code quality. While
                 refactoring is largely considered a good practice,
                 refactoring proposals in pull requests are often
                 rejected after the code review. Understanding the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Oni:2022:AUR,
  author =       "Olawole Oni and Emmanuel Letier",
  title =        "Analyzing Uncertainty in Release Planning: a Method
                 and Experiment for Fixed-Date Release Cycles",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "24:1--24:39",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490487",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490487",
  abstract =     "Release planning-deciding what features to implement
                 in upcoming releases of a software system-is a critical
                 activity in iterative software development. Many
                 release planning methods exist, but most ignore the
                 inevitable uncertainty in estimating software
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Traini:2022:HSR,
  author =       "Luca Traini and Daniele {Di Pompeo} and Michele Tucci
                 and Bin Lin and Simone Scalabrino and Gabriele Bavota
                 and Michele Lanza and Rocco Oliveto and Vittorio
                 Cortellessa",
  title =        "How Software Refactoring Impacts Execution Time",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "25:1--25:23",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3485136",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3485136",
  abstract =     "Refactoring aims at improving the maintainability of
                 source code without modifying its external behavior.
                 Previous works proposed approaches to recommend
                 refactoring solutions to software developers. The
                 generation of the recommended solutions is guided
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hough:2022:PAD,
  author =       "Katherine Hough and Jonathan Bell",
  title =        "A Practical Approach for Dynamic Taint Tracking with
                 Control-flow Relationships",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "26:1--26:43",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3485464",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3485464",
  abstract =     "Dynamic taint tracking, a technique that traces
                 relationships between values as a program executes, has
                 been used to support a variety of software engineering
                 tasks. Some taint tracking systems only consider data
                 flows and ignore control flows. As a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ford:2022:TTC,
  author =       "Denae Ford and Margaret-Anne Storey and Thomas
                 Zimmermann and Christian Bird and Sonia Jaffe and
                 Chandra Maddila and Jenna L. Butler and Brian Houck and
                 Nachiappan Nagappan",
  title =        "A Tale of Two Cities: Software Developers Working from
                 Home during the {COVID-19} Pandemic",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "27:1--27:37",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487567",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487567",
  abstract =     "The COVID-19 pandemic has shaken the world to its core
                 and has provoked an overnight exodus of developers who
                 normally worked in an office setting to working from
                 home. The magnitude of this shift and the factors that
                 have accompanied this new unplanned \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Williams:2022:GFI,
  author =       "Ryan Williams and Tongwei Ren and Lorenzo {De Carli}
                 and Long Lu and Gillian Smith",
  title =        "Guided Feature Identification and Removal for
                 Resource-constrained Firmware",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "28:1--28:25",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487568",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487568",
  abstract =     "IoT firmware oftentimes incorporates third-party
                 components, such as network-oriented middleware and
                 media encoders/decoders. These components consist of
                 large and mature codebases, shipping with a variety of
                 non-critical features. Feature bloat increases
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2022:ICG,
  author =       "Frank F. Xu and Bogdan Vasilescu and Graham Neubig",
  title =        "In-{IDE} Code Generation from Natural Language:
                 Promise and Challenges",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "29:1--29:47",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487569",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487569",
  abstract =     "A great part of software development involves
                 conceptualizing or communicating the underlying
                 procedures and logic that needs to be expressed in
                 programs. One major difficulty of programming is
                 turning concept into code, especially when dealing with
                 the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2022:WDS,
  author =       "Jiachi Chen and Xin Xia and David Lo and John Grundy",
  title =        "Why Do Smart Contracts Self-Destruct? {Investigating}
                 the Selfdestruct Function on {Ethereum}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "30:1--30:37",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3488245",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3488245",
  abstract =     "The \emph{selfdestruct} function is provided by
                 Ethereum smart contracts to destroy a contract on the
                 blockchain system. However, it is a double-edged sword
                 for developers. On the one hand, using the
                 \emph{selfdestruct} function enables developers to
                 remove {\bf smart contracts (SCs)} from Ethereum and
                 transfers Ethers when emergency situations happen,
                 e.g., being attacked. On the other hand, this function
                 can increase the complexity for the development and
                 open an attack vector for attackers. To better
                 understand the reasons why SC developers include or
                 exclude the \emph{selfdestruct} function in their
                 contracts, we conducted an online survey to collect
                 feedback from them and summarize the key reasons. Their
                 feedback shows that 66.67\% of the developers will
                 deploy an updated contract to the Ethereum after
                 destructing the old contract. According to this
                 information, we propose a method to find the
                 self-destructed contracts (also called predecessor
                 contracts) and their updated version (successor
                 contracts) by computing the code similarity. By
                 analyzing the difference between the predecessor
                 contracts and their successor contracts, we found five
                 reasons that led to the death of the contracts; two of
                 them (i.e., \emph{Unmatched ERC20 Token and Limits of
                 Permission}) might affect the life span of contracts.
                 We developed a tool named {\sc LifeScope} to detect
                 these problems. {\sc LifeScope} reports 0 false
                 positives or negatives in detecting \emph{Unmatched
                 ERC20 Token}. In terms of \pkg{Limits of Permission},
                 {\sc LifeScope} achieves 77.89\% of $F$-measure and
                 0.8673 of AUC in average. According to the feedback of
                 developers who exclude \emph{selfdestruct} functions,
                 we propose suggestions to help developers use
                 \emph{selfdestruct} functions in Ethereum smart
                 contracts better.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Keller:2022:WYS,
  author =       "Patrick Keller and Abdoul Kader Kabor{\'e} and Laura
                 Plein and Jacques Klein and Yves {Le Traon} and
                 Tegawend{\'e} F. Bissyand{\'e}",
  title =        "What You See is What it Means! {Semantic}
                 Representation Learning of Code based on Visualization
                 and Transfer Learning",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "31:1--31:34",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3485135",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3485135",
  abstract =     "Recent successes in training word embeddings for
                 Natural Language Processing (NLP) tasks have encouraged
                 a wave of research on representation learning for
                 source code, which builds on similar NLP methods. The
                 overall objective is then to produce code \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Watson:2022:SLR,
  author =       "Cody Watson and Nathan Cooper and David Nader Palacio
                 and Kevin Moran and Denys Poshyvanyk",
  title =        "A Systematic Literature Review on the Use of Deep
                 Learning in Software Engineering Research",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "32:1--32:58",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3485275",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3485275",
  abstract =     "An increasingly popular set of techniques adopted by
                 software engineering (SE) researchers to automate
                 development tasks are those rooted in the concept of
                 Deep Learning (DL). The popularity of such techniques
                 largely stems from their automated feature \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kapur:2022:OEE,
  author =       "Ritu Kapur and Balwinder Sodhi",
  title =        "{OSS} Effort Estimation Using Software Features
                 Similarity and Developer Activity-Based Metrics",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "33:1--33:35",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3485819",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3485819",
  abstract =     "Software development effort estimation (SDEE)
                 generally involves leveraging the information about the
                 effort spent in developing similar software in the
                 past. Most organizations do not have access to
                 sufficient and reliable forms of such data from past
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cao:2022:SSB,
  author =       "Jialun Cao and Meiziniu Li and Yeting Li and Ming Wen
                 and Shing-Chi Cheung and Haiming Chen",
  title =        "{SemMT}: a Semantic-Based Testing Approach for Machine
                 Translation Systems",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "34e:1--34e:36",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490488",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490488",
  abstract =     "Machine translation has wide applications in daily
                 life. In mission-critical applications such as
                 translating official documents, incorrect translation
                 can have unpleasant or sometimes catastrophic
                 consequences. This motivates recent research on the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zou:2022:BSP,
  author =       "Changwei Zou and Xudong Wang and Yaoqing Gao and
                 Jingling Xue",
  title =        "Buddy Stacks: Protecting Return Addresses with
                 Efficient Thread-Local Storage and Runtime
                 Re-Randomization",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "35e:1--35e:37",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3494516",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3494516",
  abstract =     "Shadow stacks play an important role in protecting
                 return addresses to mitigate ROP attacks. Parallel
                 shadow stacks, which shadow the call stack of each
                 thread at the same constant offset for all threads, are
                 known not to support multi-threading well. On
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ahmadjee:2022:SBA,
  author =       "Sabreen Ahmadjee and Carlos Mera-G{\'o}mez and Rami
                 Bahsoon and Rick Kazman",
  title =        "A Study on Blockchain Architecture Design Decisions
                 and Their Security Attacks and Threats",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "36e:1--36e:45",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502740",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502740",
  abstract =     "Blockchain is a disruptive technology intended to
                 implement secure decentralised distributed systems, in
                 which transactional data can be shared, stored, and
                 verified by participants of the system without needing
                 a central authentication/verification authority.
                 Blockchain-based systems have several architectural
                 components and variants, which architects can leverage
                 to build secure software systems. However, there is a
                 lack of studies to assist architects in making
                 architecture design and configuration decisions for
                 blockchain-based systems. This knowledge gap may
                 increase the chance of making unsuitable design
                 decisions and producing configurations prone to
                 potential security risks. To address this limitation,
                 we report our comprehensive systematic literature
                 review to derive a taxonomy of commonly used
                 architecture design decisions in blockchain-based
                 systems. We map each of these decisions to potential
                 security attacks and their posed threats. MITRE's
                 attack tactic categories and Microsoft STRIDE threat
                 modeling are used to systematically classify threats
                 and their associated attacks to identify potential
                 attacks and threats in blockchain-based systems. Our
                 mapping approach aims to guide architects to make
                 justifiable design decisions that will result in more
                 secure implementations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Martinez-Fernandez:2022:SEA,
  author =       "Silverio Mart{\'\i}nez-Fern{\'a}ndez and Justus Bogner
                 and Xavier Franch and Marc Oriol and Julien Siebert and
                 Adam Trendowicz and Anna Maria Vollmer and Stefan
                 Wagner",
  title =        "Software Engineering for {AI}-Based Systems: a
                 Survey",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "2",
  pages =        "37e:1--37e:59",
  month =        apr,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487043",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:20 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487043",
  abstract =     "AI-based systems are software systems with
                 functionalities enabled by at least one AI component
                 (e.g., for image-, speech-recognition, and autonomous
                 driving). AI-based systems are becoming pervasive in
                 society due to advances in AI. However, there is
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xiong:2022:LFS,
  author =       "Yingfei Xiong and Bo Wang",
  title =        "{L2S}: a Framework for Synthesizing the Most Probable
                 Program under a Specification",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "34:1--34:45",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487570",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487570",
  abstract =     "In many scenarios, we need to find the most likely
                 program that meets a specification under a local
                 context, where the local context can be an incomplete
                 program, a partial specification, natural language
                 description, and so on. We call such a problem
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2022:CFA,
  author =       "Junjie Wang and Ye Yang and Song Wang and Jun Hu and
                 Qing Wang",
  title =        "Context- and Fairness-Aware In-Process Crowdworker
                 Recommendation",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "35:1--35:31",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3487571",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3487571",
  abstract =     "Identifying and optimizing open participation is
                 essential to the success of open software development.
                 Existing studies highlighted the importance of worker
                 recommendation for crowdtesting tasks in order to
                 improve bug detection efficiency, i.e., detect
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2022:RAE,
  author =       "Yu Zhao and Ting Su and Yang Liu and Wei Zheng and
                 Xiaoxue Wu and Ramakanth Kavuluru and William G. J.
                 Halfond and Tingting Yu",
  title =        "{ReCDroid+}: Automated End-to-End Crash Reproduction
                 from Bug Reports for {Android} Apps",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "36:1--36:33",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3488244",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3488244",
  abstract =     "The large demand of mobile devices creates significant
                 concerns about the quality of mobile applications
                 (apps). Developers heavily rely on bug reports in issue
                 tracking systems to reproduce failures (e.g., crashes).
                 However, the process of crash \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DiStefano:2022:VDS,
  author =       "Luca {Di Stefano} and Rocco {De Nicola} and Omar
                 Inverso",
  title =        "Verification of Distributed Systems via Sequential
                 Emulation",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "37:1--37:41",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490387",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490387",
  abstract =     "Sequential emulation is a semantics-based technique to
                 automatically reduce property checking of distributed
                 systems to the analysis of sequential programs. An
                 automated procedure takes as input a formal
                 specification of a distributed system, a property
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lin:2022:OMS,
  author =       "Bin Lin and Nathan Cassee and Alexander Serebrenik and
                 Gabriele Bavota and Nicole Novielli and Michele Lanza",
  title =        "Opinion Mining for Software Development: a Systematic
                 Literature Review",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "38:1--38:41",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490388",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490388",
  abstract =     "Opinion mining, sometimes referred to as sentiment
                 analysis, has gained increasing attention in software
                 engineering (SE) studies. SE researchers have applied
                 opinion mining techniques in various contexts, such as
                 identifying developers' emotions \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Barcelona-Pons:2022:SSC,
  author =       "Daniel Barcelona-Pons and Pierre Sutra and Marc
                 S{\'a}nchez-Artigas and Gerard Par{\'\i}s and Pedro
                 Garc{\'\i}a-L{\'o}pez",
  title =        "Stateful Serverless Computing with Crucial",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "39:1--39:38",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490386",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490386",
  abstract =     "Serverless computing greatly simplifies the use of
                 cloud resources. In particular, Function-as-a-Service
                 (FaaS) platforms enable programmers to develop
                 applications as individual functions that can run and
                 scale independently. Unfortunately, applications
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "39",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Furia:2022:ABA,
  author =       "Carlo A. Furia and Richard Torkar and Robert Feldt",
  title =        "Applying {Bayesian} Analysis Guidelines to Empirical
                 Software Engineering Data: The Case of Programming
                 Languages and Code Quality",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "40:1--40:38",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490953",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490953",
  abstract =     "Statistical analysis is the tool of choice to turn
                 data into information and then information into
                 empirical knowledge. However, the process that goes
                 from data to knowledge is long, uncertain, and riddled
                 with pitfalls. To be valid, it should be \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "40",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Marculescu:2022:FFR,
  author =       "Bogdan Marculescu and Man Zhang and Andrea Arcuri",
  title =        "On the Faults Found in {REST APIs} by Automated Test
                 Generation",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "41:1--41:43",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3491038",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3491038",
  abstract =     "RESTful web services are often used for building a
                 wide variety of enterprise applications. The diversity
                 and increased number of applications using RESTful APIs
                 means that increasing amounts of resources are spent
                 developing and testing these systems. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "41",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Calefato:2022:UPD,
  author =       "Fabio Calefato and Filippo Lanubile",
  title =        "Using Personality Detection Tools for Software
                 Engineering Research: How Far Can We Go?",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "42:1--42:48",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3491039",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3491039",
  abstract =     "Assessing the personality of software engineers may
                 help to match individual traits with the
                 characteristics of development activities such as code
                 review and testing, as well as support managers in team
                 composition. However, self-assessment \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "42",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2022:AOD,
  author =       "Si Liu",
  title =        "All in One: Design, Verification, and Implementation
                 of {SNOW}-optimal Read Atomic Transactions",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "43:1--43:44",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3494517",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3494517",
  abstract =     "Distributed read atomic transactions are important
                 building blocks of modern cloud databases that
                 magnificently bridge the gap between data availability
                 and strong data consistency. The performance of their
                 transactional reads is particularly critical to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "43",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2022:DDR,
  author =       "Wenhua Yang and Chong Zhang and Minxue Pan and Chang
                 Xu and Yu Zhou and Zhiqiu Huang",
  title =        "Do Developers Really Know How to Use {Git} Commands?
                 {A} Large-scale Study Using {Stack Overflow}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "44:1--44:29",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3494518",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3494518",
  abstract =     "Git, a cross-platform and open source distributed
                 version control tool, provides strong support for
                 non-linear development and is capable of handling
                 everything from small to large projects with speed and
                 efficiency. It has become an indispensable tool
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "44",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Marijan:2022:IAR,
  author =       "Dusica Marijan and Sagar Sen",
  title =        "Industry-Academia Research Collaboration and Knowledge
                 Co-creation: Patterns and Anti-patterns",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "45:1--45:52",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3494519",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3494519",
  abstract =     "Increasing the impact of software engineering research
                 in the software industry and the society at large has
                 long been a concern of high priority for the software
                 engineering community. The problem of two cultures,
                 research conducted in a vacuum \ldots{}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "45",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sobhy:2022:CPS,
  author =       "Dalia Sobhy and Leandro Minku and Rami Bahsoon and
                 Rick Kazman",
  title =        "Continuous and Proactive Software Architecture
                 Evaluation: an {IoT} Case",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "46:1--46:54",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3492762",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3492762",
  abstract =     "Design-time evaluation is essential to build the
                 initial software architecture to be deployed. However,
                 experts' assumptions made at design-time are unlikely
                 to remain true indefinitely in systems that are
                 characterized by scale, hyperconnectivity, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "46",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xie:2022:NNP,
  author =       "Xiaofei Xie and Tianlin Li and Jian Wang and Lei Ma
                 and Qing Guo and Felix Juefei-Xu and Yang Liu",
  title =        "{NPC}: Neuron Path Coverage via Characterizing
                 Decision Logic of Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "47:1--47:27",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490489",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490489",
  abstract =     "Deep learning has recently been widely applied to many
                 applications across different domains, e.g., image
                 classification and audio recognition. However, the
                 quality of Deep Neural Networks (DNNs) still raises
                 concerns in the practical operational \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "47",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Uddin:2022:ESE,
  author =       "Gias Uddin and Yann-Ga{\"e}l Gu{\'e}h{\'e}nuc and
                 Foutse Khomh and Chanchal K. Roy",
  title =        "An Empirical Study of the Effectiveness of an Ensemble
                 of Stand-alone Sentiment Detection Tools for Software
                 Engineering Datasets",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "48:1--48:38",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3491211",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3491211",
  abstract =     "Sentiment analysis in software engineering (SE) has
                 shown promise to analyze and support diverse
                 development activities. Recently, several tools are
                 proposed to detect sentiments in software artifacts.
                 While the tools improve accuracy over off-the-shelf
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "48",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2022:DAM,
  author =       "Hao Guo and Sen Chen and Zhenchang Xing and Xiaohong
                 Li and Yude Bai and Jiamou Sun",
  title =        "Detecting and Augmenting Missing Key Aspects in
                 Vulnerability Descriptions",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "49:1--49:27",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3498537",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3498537",
  abstract =     "Security vulnerabilities have been continually
                 disclosed and documented. For the effective
                 understanding, management, and mitigation of the
                 fast-growing number of vulnerabilities, an important
                 practice in documenting vulnerabilities is to describe
                 the key \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "49",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2022:TRD,
  author =       "Huangzhao Zhang and Zhiyi Fu and Ge Li and Lei Ma and
                 Zhehao Zhao and Hua'an Yang and Yizhe Sun and Yang Liu
                 and Zhi Jin",
  title =        "Towards Robustness of Deep Program Processing
                 Models-Detection, Estimation, and Enhancement",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "50:1--50:40",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511887",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511887",
  abstract =     "Deep learning (DL) has recently been widely applied to
                 diverse source code processing tasks in the software
                 engineering (SE) community, which achieves competitive
                 performance (e.g., accuracy). However, the robustness,
                 which requires the model to produce \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "50",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lin:2022:CAC,
  author =       "Bo Lin and Shangwen Wang and Ming Wen and Xiaoguang
                 Mao",
  title =        "Context-Aware Code Change Embedding for Better Patch
                 Correctness Assessment",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "51:1--51:29",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3505247",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3505247",
  abstract =     "Despite the capability in successfully fixing more and
                 more real-world bugs, existing Automated Program Repair
                 (APR) techniques are still challenged by the
                 long-standing overfitting problem (i.e., a generated
                 patch that passes all tests is actually \ldots{}).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "51",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lin:2022:XTC,
  author =       "Zehao Lin and Guodun Li and Jingfeng Zhang and Yue
                 Deng and Xiangji Zeng and Yin Zhang and Yao Wan",
  title =        "{XCode}: Towards Cross-Language Code Representation
                 with Large-Scale Pre-Training",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "52:1--52:44",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3506696",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3506696",
  abstract =     "Source code representation learning is the basis of
                 applying artificial intelligence to many software
                 engineering tasks such as code clone detection,
                 algorithm classification, and code summarization.
                 Recently, many works have tried to improve the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "52",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liao:2022:ESI,
  author =       "Lizhi Liao and Heng Li and Weiyi Shang and Lei Ma",
  title =        "An Empirical Study of the Impact of Hyperparameter
                 Tuning and Model Optimization on the Performance
                 Properties of Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "53:1--53:40",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3506695",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3506695",
  abstract =     "Deep neural network (DNN) models typically have many
                 hyperparameters that can be configured to achieve
                 optimal performance on a particular dataset.
                 Practitioners usually tune the hyperparameters of their
                 DNN models by training a number of trial models
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "53",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2022:TTI,
  author =       "Siwei Wu and Lei Wu and Yajin Zhou and Runhuai Li and
                 Zhi Wang and Xiapu Luo and Cong Wang and Kui Ren",
  title =        "Time-travel Investigation: Toward Building a Scalable
                 Attack Detection Framework on {Ethereum}",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "54:1--54:33",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3505263",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3505263",
  abstract =     "Ethereum has been attracting lots of attacks, hence
                 there is a pressing need to perform timely
                 investigation and detect more attack instances.
                 However, existing systems suffer from the scalability
                 issue due to the following reasons. First, the tight
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "54",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Meyers:2022:EPT,
  author =       "Benjamin S. Meyers and Sultan Fahad Almassari and
                 Brandon N. Keller and Andrew Meneely",
  title =        "Examining Penetration Tester Behavior in the
                 Collegiate Penetration Testing Competition",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "55:1--55:25",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3514040",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3514040",
  abstract =     "Penetration testing is a key practice toward
                 engineering secure software. Malicious actors have many
                 tactics at their disposal, and software engineers need
                 to know what tactics attackers will prioritize in the
                 first few hours of an attack. Projects like \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "55",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2022:PMS,
  author =       "Yanming Yang and Xin Xia and David Lo and Tingting Bi
                 and John Grundy and Xiaohu Yang",
  title =        "Predictive Models in Software Engineering: Challenges
                 and Opportunities",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "3",
  pages =        "56:1--56:72",
  month =        jul,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3503509",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Tue May 24 07:09:22 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3503509",
  abstract =     "Predictive models are one of the most important
                 techniques that are widely applied in many areas of
                 software engineering. There have been a large number of
                 primary studies that apply predictive models and that
                 present well-performed studies in various \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "56",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Beyer:2022:VW,
  author =       "Dirk Beyer and Matthias Dangl and Daniel Dietsch and
                 Matthias Heizmann and Thomas Lemberger and Michael
                 Tautschnig",
  title =        "Verification Witnesses",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "57:1--57:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3477579",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477579",
  abstract =     "Over the last years, witness-based validation of
                 verification results has become an established practice
                 in software verification: An independent validator
                 re-establishes verification results of a software
                 verifier using verification witnesses, which are
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "57",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jain:2022:BRD,
  author =       "Ridhi Jain and Rahul Purandare and Subodh Sharma",
  title =        "{BiRD}: Race Detection in Software Binaries under
                 Relaxed Memory Models",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "58:1--58:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3498538",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3498538",
  abstract =     "Instruction reordering and interleavings in program
                 execution under relaxed memory semantics result in
                 non-intuitive behaviors, making it difficult to provide
                 assurances about program correctness. Studies have
                 shown that up to 90\% of the concurrency bugs
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "58",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Masso:2022:CTS,
  author =       "Jhon Masso and F{\'e}lix Garc{\'\i}a and C{\'e}sar
                 Pardo and Francisco J. Pino and Mario Piattini",
  title =        "A Common Terminology for Software Risk Management",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "59:1--59:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3498539",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3498539",
  abstract =     "In order to improve and sustain their competitiveness
                 over time, organisations nowadays need to undertake
                 different initiatives to adopt frameworks, models and
                 standards that will allow them to align and improve
                 their business processes. In spite of these \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "59",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2022:ARD,
  author =       "Yu Zhou and Xiaoqing Zhang and Juanjuan Shen and
                 Tingting Han and Taolue Chen and Harald Gall",
  title =        "Adversarial Robustness of Deep Code Comment
                 Generation",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "60:1--60:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3501256",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3501256",
  abstract =     "Deep neural networks (DNNs) have shown remarkable
                 performance in a variety of domains such as computer
                 vision, speech recognition, and natural language
                 processing. Recently they also have been applied to
                 various software engineering tasks, typically
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "60",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ngo:2022:ACE,
  author =       "Chanh Duc Ngo and Fabrizio Pastore and Lionel Briand",
  title =        "Automated, Cost-effective, and Update-driven App
                 Testing",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "61:1--61:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502297",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502297",
  abstract =     "Apps' pervasive role in our society led to the
                 definition of test automation approaches to ensure
                 their dependability. However, state-of-the-art
                 approaches tend to generate large numbers of test
                 inputs and are unlikely to achieve more than 50\%
                 method \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "61",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yu:2022:AIE,
  author =       "Hao Yu and Xing Hu and Ge Li and Ying Li and Qianxiang
                 Wang and Tao Xie",
  title =        "Assessing and Improving an Evaluation Dataset for
                 Detecting Semantic Code Clones via Deep Learning",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "62:1--62:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502852",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502852",
  abstract =     "In recent years, applying deep learning to detect
                 semantic code clones has received substantial attention
                 from the research community. Accordingly, various
                 evaluation benchmark datasets, with the most popular
                 one as BigCloneBench, are constructed and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "62",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2022:CAH,
  author =       "Xing Hu and Qiuyuan Chen and Haoye Wang and Xin Xia
                 and David Lo and Thomas Zimmermann",
  title =        "Correlating Automated and Human Evaluation of Code
                 Documentation Generation Quality",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "63:1--63:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502853",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502853",
  abstract =     "Automatic code documentation generation has been a
                 crucial task in the field of software engineering. It
                 not only relieves developers from writing code
                 documentation but also helps them to understand
                 programs better. Specifically, deep-learning-based
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "63",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Andre:2022:GTO,
  author =       "{\'E}tienne Andr{\'e} and Didier Lime and Dylan
                 Marinho and Jun Sun",
  title =        "Guaranteeing Timed Opacity using Parametric Timed
                 Model Checking",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "64:1--64:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502851",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502851",
  abstract =     "Information leakage can have dramatic consequences on
                 systems security. Among harmful information leaks, the
                 timing information leakage occurs whenever an attacker
                 successfully deduces confidential internal information.
                 In this work, we consider that the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "64",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Romdhana:2022:DRL,
  author =       "Andrea Romdhana and Alessio Merlo and Mariano Ceccato
                 and Paolo Tonella",
  title =        "Deep Reinforcement Learning for Black-box Testing of
                 {Android} Apps",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "65:1--65:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3502868",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502868",
  abstract =     "The state space of Android apps is huge, and its
                 thorough exploration during testing remains a
                 significant challenge. The best exploration strategy is
                 highly dependent on the features of the app under test.
                 Reinforcement Learning (RL) is a machine \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "65",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bi:2022:ASP,
  author =       "Tingting Bi and Xin Xia and David Lo and John Grundy
                 and Thomas Zimmermann and Denae Ford",
  title =        "Accessibility in Software Practice: a Practitioner's
                 Perspective",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "66:1--66:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3503508",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3503508",
  abstract =     "Being able to access software in daily life is vital
                 for everyone, and thus accessibility is a fundamental
                 challenge for software development. However, given the
                 number of accessibility issues reported by many users,
                 e.g., in app reviews, it is not clear \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "66",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Joblin:2022:HDS,
  author =       "Mitchell Joblin and Sven Apel",
  title =        "How Do Successful and Failed Projects Differ? {A}
                 Socio-Technical Analysis",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "67:1--67:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3504003",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3504003",
  abstract =     "Software development is at the intersection of the
                 social realm, involving people who develop the
                 software, and the technical realm, involving artifacts
                 (code, docs, etc.) that are being produced. It has been
                 shown that a socio-technical perspective. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "67",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DeGiacomo:2022:MCM,
  author =       "Giuseppe {De Giacomo} and Riccardo {De Masellis} and
                 Fabrizio Maria Maggi and Marco Montali",
  title =        "Monitoring Constraints and Metaconstraints with
                 Temporal Logics on Finite Traces",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "68:1--68:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3506799",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3506799",
  abstract =     "Runtime monitoring is a central operational decision
                 support task in business process management. It helps
                 process executors to check on-the-fly whether a running
                 process instance satisfies business constraints of
                 interest, providing an immediate feedback \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "68",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2022:MRE,
  author =       "Peng Zhang and Yang Wang and Xutong Liu and Yanhui Li
                 and Yibiao Yang and Ziyuan Wang and Xiaoyu Zhou and Lin
                 Chen and Yuming Zhou",
  title =        "Mutant Reduction Evaluation: What is There and What is
                 Missing?",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "69:1--69:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3522578",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3522578",
  abstract =     "Background. Mutation testing is a commonly used defect
                 injection technique for evaluating the effectiveness of
                 a test suite. However, it is usually computationally
                 expensive. Therefore, many mutation reduction
                 strategies, which aim to reduce the number of
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "69",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Albert:2022:SOS,
  author =       "Elvira Albert and Pablo Gordillo and Alejandro
                 Hern{\'a}ndez-Cerezo and Albert Rubio and Maria A.
                 Schett",
  title =        "Super-optimization of Smart Contracts",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "70:1--70:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3506800",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3506800",
  abstract =     "Smart contracts are programs deployed on a blockchain.
                 They are executed for a monetary fee paid in gas -a
                 clear optimization target for smart contract compilers.
                 Because smart contracts are a young, fast-moving field
                 without (manually) fine-tuned \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "70",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lauko:2022:VPS,
  author =       "Henrich Lauko and Luk{\'a}s Korencik and Petr Rockai",
  title =        "Verification of Programs Sensitive to Heap Layout",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "71:1--71:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3508363",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3508363",
  abstract =     "Most C and C++ programs use dynamically allocated
                 memory (often known as a heap) to store and organize
                 their data. In practice, it can be useful to compare
                 addresses of different heap objects, for instance, to
                 store them in a binary search tree or a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "71",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2022:BCT,
  author =       "Junjie Chen and Chenyao Suo",
  title =        "Boosting Compiler Testing via Compiler Optimization
                 Exploration",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "72:1--72:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3508362",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3508362",
  abstract =     "Compilers are a kind of important software, and
                 similar to the quality assurance of other software,
                 compiler testing is one of the most widely-used ways of
                 guaranteeing their quality. Compiler bugs tend to occur
                 in compiler optimizations. Detecting \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "72",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kim:2022:PMA,
  author =       "Jinhan Kim and Juyoung Jeon and Shin Hong and Shin
                 Yoo",
  title =        "Predictive Mutation Analysis via the Natural Language
                 Channel in Source Code",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "73:1--73:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3510417",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3510417",
  abstract =     "Mutation analysis can provide valuable insights into
                 both the system under test and its test suite. However,
                 it is not scalable due to the cost of building and
                 testing a large number of mutants. Predictive Mutation
                 Testing (PMT) has been proposed to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "73",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ahmed:2022:VVR,
  author =       "Umair Z. Ahmed and Zhiyu Fan and Jooyong Yi and Omar
                 I. Al-Bataineh and Abhik Roychoudhury",
  title =        "{Verifix}: Verified Repair of Programming
                 Assignments",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "74:1--74:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3510418",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3510418",
  abstract =     "Automated feedback generation for introductory
                 programming assignments is useful for programming
                 education. Most works try to generate feedback to
                 correct a student program by comparing its behavior
                 with an instructor's reference program on selected
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "74",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2022:TCO,
  author =       "Yuxia Zhang and Hui Liu and Xin Tan and Minghui Zhou
                 and Zhi Jin and Jiaxin Zhu",
  title =        "Turnover of Companies in {OpenStack}: Prevalence and
                 Rationale",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "75:1--75:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3510849",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3510849",
  abstract =     "To achieve commercial goals, companies have made
                 substantial contributions to large open-source software
                 (OSS) ecosystems such as OpenStack and have become the
                 main contributors. However, they often withdraw their
                 employees for a variety of reasons, which \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "75",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ni:2022:JTD,
  author =       "Chao Ni and Xin Xia and David Lo and Xiaohu Yang and
                 Ahmed E. Hassan",
  title =        "Just-In-Time Defect Prediction on {JavaScript}
                 Projects: a Replication Study",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "76:1--76:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3508479",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3508479",
  abstract =     "Change-level defect prediction is widely referred to
                 as just-in-time (JIT) defect prediction since it
                 identifies a defect-inducing change at the check-in
                 time, and researchers have proposed many approaches
                 based on the language-independent change-level
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "76",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tian:2022:PPC,
  author =       "Haoye Tian and Yinghua Li and Weiguo Pian and Abdoul
                 Kader Kabor{\'e} and Kui Liu and Andrew Habib and
                 Jacques Klein and Tegawend{\'e} F. Bissyand{\'e}",
  title =        "Predicting Patch Correctness Based on the Similarity
                 of Failing Test Cases",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "77:1--77:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511096",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511096",
  abstract =     "How do we know a generated patch is correct? This is a
                 key challenging question that automated program repair
                 (APR) systems struggle to address given the
                 incompleteness of available test suites. Our intuition
                 is that we can triage correct patches by \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "77",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2022:ESD,
  author =       "Qiang Hu and Yuejun Guo and Maxime Cordy and Xiaofei
                 Xie and Lei Ma and Mike Papadakis and Yves {Le Traon}",
  title =        "An Empirical Study on Data Distribution-Aware Test
                 Selection for Deep Learning Enhancement",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "78:1--78:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511598",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511598",
  abstract =     "Similar to traditional software that is constantly
                 under evolution, deep neural networks need to evolve
                 upon the rapid growth of test data for continuous
                 enhancement (e.g., adapting to distribution shift in a
                 new environment for deployment). However, it \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "78",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Catak:2022:UAP,
  author =       "Ferhat Ozgur Catak and Tao Yue and Shaukat Ali",
  title =        "Uncertainty-aware Prediction Validator in Deep
                 Learning Models for Cyber-physical System Data",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "79:1--79:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3527451",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527451",
  abstract =     "The use of Deep learning in Cyber-Physical Systems
                 (CPSs) is gaining popularity due to its ability to
                 bring intelligence to CPS behaviors. However, both CPSs
                 and deep learning have inherent uncertainty. Such
                 uncertainty, if not handled adequately, can \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "79",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Biagiola:2022:TPR,
  author =       "Matteo Biagiola and Paolo Tonella",
  title =        "Testing the Plasticity of Reinforcement Learning-based
                 Systems",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "80:1--80:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511701",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511701",
  abstract =     "The dataset available for pre-release training of a
                 machine-learning based system is often not
                 representative of all possible execution contexts that
                 the system will encounter in the field. Reinforcement
                 Learning (RL) is a prominent approach among those
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "80",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Trinkenreich:2022:WPO,
  author =       "Bianca Trinkenreich and Igor Wiese and Anita Sarma and
                 Marco Gerosa and Igor Steinmacher",
  title =        "Women's Participation in Open Source Software: a
                 Survey of the Literature",
  journal =      j-TOSEM,
  volume =       "31",
  number =       "4",
  pages =        "81:1--81:??",
  month =        oct,
  year =         "2022",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3510460",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Nov 16 08:26:42 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3510460",
  abstract =     "Women are underrepresented in Open Source Software
                 (OSS) projects, as a result of which, not only do women
                 lose career and skill development opportunities, but
                 the projects themselves suffer from a lack of diversity
                 of perspectives. Practitioners and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "81",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2023:EAS,
  author =       "Mauro Pezz{\`e}",
  title =        "{Editorial}: Announcing Six {TOSEM} Issues Per Year",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583569",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583569",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Robol:2023:CVM,
  author =       "Marco Robol and Travis D. Breaux and Elda Paja and
                 Paolo Giorgini",
  title =        "Consent Verification Monitoring",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3490754",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490754",
  abstract =     "Advances in personalization of digital services are
                 driven by low-cost data collection and processing, in
                 addition to the wide variety of third-party frameworks
                 for authentication, storage, and marketing. New privacy
                 regulations, such as the General Data \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nie:2023:CDD,
  author =       "Pengbo Nie and Chengcheng Wan and Jiayu Zhu and Ziyi
                 Lin and Yuting Chen and Zhendong Su",
  title =        "Coverage-directed Differential Testing of {X.509}
                 Certificate Validation in {SSL\slash TLS}
                 Implementations",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3510416",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3510416",
  abstract =     "Secure Sockets Layer (SSL) and Transport Security
                 (TLS) are two secure protocols for creating secure
                 connections over the Internet. X.509 certificate
                 validation is important for security and needs to be
                 performed before an SSL/TLS connection is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pan:2023:PWT,
  author =       "Minxue Pan and Yifei Lu and Yu Pei and Tian Zhang and
                 Xuandong Li",
  title =        "Preference-wise Testing of {Android} Apps via Test
                 Amplification",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511804",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511804",
  abstract =     "Preferences, the setting options provided by Android,
                 are an essential part of Android apps. Preferences
                 allow users to change app features and behaviors
                 dynamically, and therefore their impacts need to be
                 considered when testing the apps. Unfortunately,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:WCH,
  author =       "Tao Chen and Miqing Li",
  title =        "The Weights Can Be Harmful: {Pareto} Search versus
                 Weighted Search in Multi-objective Search-based
                 Software Engineering",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "5:1--5:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3514233",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3514233",
  abstract =     "In presence of multiple objectives to be optimized in
                 Search-Based Software Engineering (SBSE), Pareto search
                 has been commonly adopted. It searches for a good
                 approximation of the problem's Pareto-optimal
                 solutions, from which the stakeholders choose the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bertolotti:2023:FTS,
  author =       "Francesco Bertolotti and Walter Cazzola",
  title =        "{Fold2Vec}: Towards a Statement-Based Representation
                 of Code for Code Comprehension",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "6:1--6:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3514232",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3514232",
  abstract =     "We introduce a novel approach to source code
                 representation to be used in combination with neural
                 networks. Such a representation is designed to permit
                 the production of a continuous vector for each code
                 statement. In particular, we present how the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yin:2023:SEV,
  author =       "Zijing Yin and Yiwen Xu and Fuchen Ma and Haohao Gao
                 and Lei Qiao and Yu Jiang",
  title =        "{Scanner++}: Enhanced Vulnerability Detection of {Web}
                 Applications with Attack Intent Synchronization",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "7:1--7:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3517036",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3517036",
  abstract =     "Scanners are commonly applied for detecting
                 vulnerabilities in web applications. Various scanners
                 with different strategies are widely in use, but their
                 performance is challenged by the increasing diversity
                 of target applications that have more complex
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dong:2023:BWL,
  author =       "Yiwen Dong and Zheyang Li and Yongqiang Tian and
                 Chengnian Sun and Michael W. Godfrey and Meiyappan
                 Nagappan",
  title =        "{Bash} in the Wild: Language Usage, Code Smells, and
                 Bugs",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "8:1--8:22",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3517193",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3517193",
  abstract =     "The Bourne-again shell (Bash) is a prevalent scripting
                 language for orchestrating shell commands and managing
                 resources in Unix-like environments. It is one of the
                 mainstream shell dialects that is available on most GNU
                 Linux systems. However, the unique syntax and semantics
                 of Bash could easily lead to unintended behaviors if
                 carelessly used. Prior studies primarily focused on
                 improving the reliability of Bash scripts or
                 facilitating writing Bash scripts; there is yet no
                 empirical study on the characteristics of Bash programs
                 written in reality, e.g., frequently used language
                 features, common code smells, and bugs.\par

                 In this article, we perform a large-scale empirical
                 study of Bash usage, based on analyses over one million
                 open source Bash scripts found in Github repositories.
                 We identify and discuss which features and utilities of
                 Bash are most often used. Using static analysis, we
                 find that Bash scripts are often error-prone, and the
                 error-proneness has a moderately positive correlation
                 with the size of the scripts. We also find that the
                 most common problem areas concern quoting, resource
                 management, command options, permissions, and error
                 handling. We envision that these findings can be
                 beneficial for learning Bash and future research that
                 aims to improve shell and command-line productivity and
                 reliability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2023:SFC,
  author =       "Xiong Xu and Jean-Pierre Talpin and Shuling Wang and
                 Bohua Zhan and Naijun Zhan",
  title =        "Semantics Foundation for Cyber-physical Systems Using
                 Higher-order {UTP}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "9:1--9:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3517192",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3517192",
  abstract =     "Model-based design has become the predominant approach
                 to the design of hybrid and cyber-physical systems
                 (CPSs). It advocates the use of mathematically founded
                 models to capture heterogeneous digital and analog
                 behaviours from domain-specific formalisms, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Waga:2023:PTP,
  author =       "Masaki Waga and {\'E}tienne Andr{\'e} and Ichiro
                 Hasuo",
  title =        "Parametric Timed Pattern Matching",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "10:1--10:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3517194",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3517194",
  abstract =     "Given a log and a specification, timed pattern
                 matching aims at exhibiting for which start and end
                 dates a specification holds on that log. For example,
                 ``a given action is always followed by another action
                 before a given deadline''. This problem has strong
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rombaut:2023:TNS,
  author =       "Benjamin Rombaut and Filipe R. Cogo and Bram Adams and
                 Ahmed E. Hassan",
  title =        "There's no Such Thing as a Free Lunch: Lessons Learned
                 from Exploring the Overhead Introduced by the
                 Greenkeeper Dependency Bot in {Npm}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "11:1--11:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3522587",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3522587",
  abstract =     "Dependency management bots are increasingly being used
                 to support the software development process, for
                 example, to automatically update a dependency when a
                 new version is available. Yet, human intervention is
                 often required to either accept or reject any
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Weyns:2023:AFF,
  author =       "Danny Weyns and Usman M. Iftikhar",
  title =        "{ActivFORMS}: a Formally Founded Model-based Approach
                 to Engineer Self-adaptive Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "12:1--12:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3522585",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3522585",
  abstract =     "Self-adaptation equips a computing system with a
                 feedback loop that enables it to deal with change
                 caused by uncertainties during operation, such as
                 changing availability of resources and fluctuating
                 workloads. To ensure that the system complies with the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2023:CEI,
  author =       "Xueliang Li and Junyang Chen and Yepang Liu and
                 Kaishun Wu and John P. Gallagher",
  title =        "Combatting Energy Issues for Mobile Applications",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "13:1--13:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3527851",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527851",
  abstract =     "Energy efficiency is an important criterion to judge
                 the quality of mobile apps, but one third of our
                 arbitrarily sampled apps suffer from energy issues that
                 can quickly drain battery power. To understand these
                 issues, we conduct an empirical study on 36 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ojdanic:2023:MTE,
  author =       "Milos Ojdanic and Ezekiel Soremekun and Renzo
                 Degiovanni and Mike Papadakis and Yves {Le Traon}",
  title =        "Mutation Testing in Evolving Systems: Studying the
                 Relevance of Mutants to Code Evolution",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "14:1--14:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3530786",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3530786",
  abstract =     "Context: When software evolves, opportunities for
                 introducing faults appear. Therefore, it is important
                 to test the evolved program behaviors during each
                 evolution cycle. However, while software evolves, its
                 complexity is also evolving, introducing \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Khatoonabadi:2023:WCU,
  author =       "Sayedhassan Khatoonabadi and Diego Elias Costa and
                 Rabe Abdalkareem and Emad Shihab",
  title =        "On Wasted Contributions: Understanding the Dynamics of
                 Contributor-Abandoned Pull Requests --- a Mixed-Methods
                 Study of 10 Large Open-Source Projects",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "15:1--15:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3530785",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3530785",
  abstract =     "Pull-based development has enabled numerous volunteers
                 to contribute to open-source projects with fewer
                 barriers. Nevertheless, a considerable amount of pull
                 requests (PRs) with valid contributions are abandoned
                 by their contributors, wasting the effort \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zdun:2023:MSM,
  author =       "Uwe Zdun and Pierre-Jean Queval and Georg Simhandl and
                 Riccardo Scandariato and Somik Chakravarty and Marjan
                 Jelic and Aleksandar Jovanovic",
  title =        "Microservice Security Metrics for Secure
                 Communication, Identity Management, and Observability",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "16:1--16:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3532183",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3532183",
  abstract =     "Microservice architectures are increasingly being used
                 to develop application systems. Despite many guidelines
                 and best practices being published, architecting
                 microservice systems for security is challenging.
                 Reasons are the size and complexity of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arrieta:2023:SSS,
  author =       "Aitor Arrieta and Pablo Valle and Joseba A. Agirre and
                 Goiuria Sagardui",
  title =        "Some Seeds Are Strong: Seeding Strategies for
                 Search-based Test Case Selection",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "17:1--17:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3532182",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3532182",
  abstract =     "The time it takes software systems to be tested is
                 usually long. Search-based test selection has been a
                 widely investigated technique to optimize the testing
                 process. In this article, we propose a set of seeding
                 strategies for the test case selection \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2023:AIU,
  author =       "Jianwei Wu and James Clause",
  title =        "Automated Identification of Uniqueness in {JUnit}
                 Tests",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "18:1--18:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3533313",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3533313",
  abstract =     "In the context of testing, descriptive test names are
                 desirable because they document the purpose of tests
                 and facilitate comprehension tasks during maintenance.
                 Unfortunately, prior work has shown that tests often do
                 not have descriptive names. To \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lin:2023:CEW,
  author =       "Jiahuei Lin and Mohammed Sayagh and Ahmed E. Hassan",
  title =        "The Co-evolution of the {WordPress} Platform and Its
                 Plugins",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "19:1--19:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3533700",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3533700",
  abstract =     "One can extend the features of a software system by
                 installing a set of additional components called
                 plugins. WordPress, as a typical example of such
                 plugin-based software ecosystems, is used by millions
                 of websites and has a large number (i.e., 54,777)
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2023:FDM,
  author =       "Chang-Ai Sun and Hepeng Dai and Huai Liu and Tsong
                 Yueh Chen",
  title =        "Feedback-Directed Metamorphic Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "20:1--20:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3533314",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3533314",
  abstract =     "Over the past decade, metamorphic testing has gained
                 rapidly increasing attention from both academia and
                 industry, particularly thanks to its high efficacy on
                 revealing real-life software faults in a wide variety
                 of application domains. On the basis of a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ramirez:2023:TIA,
  author =       "Aurora Ram{\'\i}rez and Robert Feldt and Jos{\'e}
                 Ra{\'u}l Romero",
  title =        "A Taxonomy of Information Attributes for Test Case
                 Prioritisation: Applicability, Machine Learning",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "21:1--21:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3511805",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3511805",
  abstract =     "Most software companies have extensive test suites and
                 re-run parts of them continuously to ensure that recent
                 changes have no adverse effects. Since test suites are
                 costly to execute, industry needs methods for test case
                 prioritisation (TCP). Recently, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2023:LLI,
  author =       "Sihan Xu and Ya Gao and Lingling Fan and Zheli Liu and
                 Yang Liu and Hua Ji",
  title =        "{LiDetector}: License Incompatibility Detection for
                 Open Source Software",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "22:1--22:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3518994",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3518994",
  abstract =     "Open-source software (OSS) licenses dictate the
                 conditions, which should be followed to reuse,
                 distribute, and modify software. Apart from widely-used
                 licenses such as the MIT License, developers are also
                 allowed to customize their own licenses (called
                 \ldots{})",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2023:CSG,
  author =       "Shuzheng Gao and Cuiyun Gao and Yulan He and Jichuan
                 Zeng and Lunyiu Nie and Xin Xia and Michael Lyu",
  title =        "Code Structure-Guided Transformer for Source Code
                 Summarization",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "23:1--23:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3522674",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3522674",
  abstract =     "Code summaries help developers comprehend programs and
                 reduce their time to infer the program functionalities
                 during software maintenance. Recent efforts resort to
                 deep learning techniques such as sequence-to-sequence
                 models for generating accurate code \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sworna:2023:AFA,
  author =       "Zarrin Tasnim Sworna and Chadni Islam and Muhammad Ali
                 Babar",
  title =        "{APIRO}: a Framework for Automated Security Tools
                 {API} Recommendation",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "24:1--24:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3512768",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3512768",
  abstract =     "Security Orchestration, Automation, and Response
                 (SOAR) platforms integrate and orchestrate a wide
                 variety of security tools to accelerate the operational
                 activities of Security Operation Center (SOC).
                 Integration of security tools in a SOAR platform is
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sayar:2023:DSJ,
  author =       "Imen Sayar and Alexandre Bartel and Eric Bodden and
                 Yves {Le Traon}",
  title =        "An In-depth Study of {Java} Deserialization
                 Remote-Code Execution Exploits and Vulnerabilities",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "25:1--25:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3554732",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3554732",
  abstract =     "Nowadays, an increasing number of applications use
                 deserialization. This technique, based on rebuilding
                 the instance of objects from serialized byte streams,
                 can be dangerous since it can open the application to
                 attacks such as remote code execution (RCE) \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{He:2023:TAE,
  author =       "Zheyuan He and Shuwei Song and Yang Bai and Xiapu Luo
                 and Ting Chen and Wensheng Zhang and Peng He and
                 Hongwei Li and Xiaodong Lin and Xiaosong Zhang",
  title =        "{TokenAware}: Accurate and Efficient Bookkeeping
                 Recognition for Token Smart Contracts",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "26:1--26:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3560263",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3560263",
  abstract =     "Tokens have become an essential part of blockchain
                 ecosystem, so recognizing token transfer behaviors is
                 crucial for applications depending on blockchain.
                 Unfortunately, existing solutions cannot recognize
                 token transfer behaviors accurately and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tamasauskaite:2023:DKG,
  author =       "Gyte Tamasauskaite and Paul Groth",
  title =        "Defining a Knowledge Graph Development Process Through
                 a Systematic Review",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "1",
  pages =        "27:1--27:??",
  month =        jan,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3522586",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 5 10:29:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3522586",
  abstract =     "Knowledge graphs are widely used in industry and
                 studied within the academic community. However, the
                 models applied in the development of knowledge graphs
                 vary. Analysing and providing a synthesis of the
                 commonly used approaches to knowledge graph \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Birchler:2023:SMO,
  author =       "Christian Birchler and Sajad Khatiri and Pouria
                 Derakhshanfar and Sebastiano Panichella and Annibale
                 Panichella",
  title =        "Single and Multi-objective Test Cases Prioritization
                 for Self-driving Cars in Virtual Environments",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "28:1--28:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3533818",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3533818",
  abstract =     "Testing with simulation environments helps to identify
                 critical failing scenarios for self-driving cars
                 (SDCs). Simulation-based tests are safer than in-field
                 operational tests and allow detecting software defects
                 before deployment. However, these tests \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Banach:2023:GRR,
  author =       "Richard Banach",
  title =        "Graded Refinement, Retrenchment, and Simulation",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "29:1--29:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3534116",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3534116",
  abstract =     "Refinement of formal system models towards
                 implementation has been a mainstay of system
                 development since the inception of formal and Correct
                 by Construction approaches to system development.
                 However, pure refinement approaches do not always deal
                 fluently \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2023:SCP,
  author =       "Zhen Yang and Jacky Wai Keung and Xiao Yu and Yan Xiao
                 and Zhi Jin and Jingyu Zhang",
  title =        "On the Significance of Category Prediction for
                 Code-Comment Synchronization",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "30:1--30:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3534117",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3534117",
  abstract =     "Software comments sometimes are not promptly updated
                 in sync when the associated code is changed. The
                 inconsistency between code and comments may mislead the
                 developers and result in future bugs. Thus, studies
                 concerning code-comment synchronization have \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Burgueno:2023:DBU,
  author =       "Lola Burgue{\~n}o and Paula Mu{\~n}oz and Robert
                 Claris{\'o} and Jordi Cabot and S{\'e}bastien
                 G{\'e}rard and Antonio Vallecillo",
  title =        "Dealing with Belief Uncertainty in Domain Models",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "31:1--31:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542947",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542947",
  abstract =     "There are numerous domains in which information
                 systems need to deal with uncertain information. These
                 uncertainties may originate from different reasons such
                 as vagueness, imprecision, incompleteness, or
                 inconsistencies, and in many cases, they cannot be
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Partachi:2023:AMI,
  author =       "Profir-Petru P{\^a}rtachi and David R. White and Earl
                 T. Barr",
  title =        "{Aide-m{\'e}moire}: Improving a Project's Collective
                 Memory via Pull Request-Issue Links",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "32:1--32:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542937",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542937",
  abstract =     "Links between pull request and the issues they address
                 document and accelerate the development of a software
                 project but are often omitted. We present a new tool,
                 Aide-m{\'e}moire, to suggest such links when a
                 developer submits a pull request or closes an
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Khanfir:2023:IBR,
  author =       "Ahmed Khanfir and Anil Koyuncu and Mike Papadakis and
                 Maxime Cordy and Tegawende F. Bissyand{\'e} and Jacques
                 Klein and Yves {Le Traon}",
  title =        "{iBiR}: Bug-report-driven Fault Injection",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "33:1--33:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542946",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542946",
  abstract =     "Much research on software engineering relies on
                 experimental studies based on fault injection. Fault
                 injection, however, is not often relevant to emulate
                 real-world software faults since it ``blindly'' injects
                 large numbers of faults. It remains indeed \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zeng:2023:DEV,
  author =       "Chen Zeng and Yue Yu and Shanshan Li and Xin Xia and
                 Zhiming Wang and Mingyang Geng and Linxiao Bai and Wei
                 Dong and Xiangke Liao",
  title =        "{deGraphCS}: Embedding Variable-based Flow Graph for
                 Neural Code Search",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "34:1--34:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546066",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546066",
  abstract =     "With the rapid increase of public code repositories,
                 developers maintain a great desire to retrieve precise
                 code snippets by using natural language. Despite
                 existing deep learning-based approaches that provide
                 end-to-end solutions (i.e., accept natural \ldots{})",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Maddila:2023:NAO,
  author =       "Chandra Maddila and Sai Surya Upadrasta and Chetan
                 Bansal and Nachiappan Nagappan and Georgios Gousios and
                 Arie van Deursen",
  title =        "{Nudge}: Accelerating Overdue Pull Requests toward
                 Completion",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "35:1--35:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3544791",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3544791",
  abstract =     "Pull requests are a key part of the collaborative
                 software development and code review process today.
                 However, pull requests can also slow down the software
                 development process when the reviewer(s) or the author
                 do not actively engage with the pull \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zuo:2023:TME,
  author =       "Zhiqiang Zuo and Xintao Niu and Siyi Zhang and Lu Fang
                 and Siau Cheng Khoo and Shan Lu and Chengnian Sun and
                 Guoqing Harry Xu",
  title =        "Toward More Efficient Statistical Debugging with
                 Abstraction Refinement",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "36:1--36:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3544790",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3544790",
  abstract =     "Debugging is known to be a notoriously painstaking and
                 time-consuming task. As one major family of automated
                 debugging, statistical debugging approaches have been
                 well investigated over the past decade, which collect
                 failing and passing executions and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lee:2023:EPS,
  author =       "Jaekwon Lee and Seung Yeob Shin and Shiva Nejati and
                 Lionel Briand and Yago Isasi Parache",
  title =        "Estimating Probabilistic Safe {WCET} Ranges of
                 Real-Time Systems at Design Stages",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "37:1--37:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546941",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546941",
  abstract =     "Estimating worst-case execution time (WCET) is an
                 important activity at early design stages of real-time
                 systems. Based on WCET estimates, engineers make design
                 and implementation decisions to ensure that task
                 executions always complete before their \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Soto-Valero:2023:CBD,
  author =       "C{\'e}sar Soto-Valero and Thomas Durieux and Nicolas
                 Harrand and Benoit Baudry",
  title =        "Coverage-Based Debloating for {Java} Bytecode",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "38:1--38:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546948",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546948",
  abstract =     "Software bloat is code that is packaged in an
                 application but is actually not necessary to run the
                 application. The presence of software bloat is an issue
                 for security, performance, and for maintenance. In this
                 article, we introduce a novel technique for \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dramko:2023:DDN,
  author =       "Luke Dramko and Jeremy Lacomis and Pengcheng Yin and
                 Ed Schwartz and Miltiadis Allamanis and Graham Neubig
                 and Bogdan Vasilescu and Claire {Le Goues}",
  title =        "{DIRE} and its Data: Neural Decompiled Variable
                 Renamings with Respect to Software Class",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "39:1--39:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546946",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546946",
  abstract =     "The decompiler is one of the most common tools for
                 examining executable binaries without the corresponding
                 source code. It transforms binaries into high-level
                 code, reversing the compilation process. Unfortunately,
                 decompiler output is far from readable \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "39",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shen:2023:CSM,
  author =       "Bowen Shen and Muhammad Ali Gulzar and Fei He and Na
                 Meng",
  title =        "A Characterization Study of Merge Conflicts in {Java}
                 Projects",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "40:1--40:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546944",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546944",
  abstract =     "In collaborative software development, programmers
                 create software branches to add features and fix bugs
                 tentatively, and then merge branches to integrate
                 edits. When edits from different branches textually
                 overlap (i.e., textual conflicts ) or lead to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "40",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Costea:2023:HDR,
  author =       "Andreea Costea and Abhishek Tiwari and Sigmund
                 Chianasta and Kishore R. and Abhik Roychoudhury and
                 Ilya Sergey",
  title =        "{Hippodrome}: Data Race Repair Using Static Analysis
                 Summaries",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "41:1--41:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546942",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546942",
  abstract =     "Implementing bug-free concurrent programs is a
                 challenging task in modern software development.
                 State-of-the-art static analyses find hundreds of
                 concurrency bugs in production code, scaling to large
                 codebases. Yet, fixing these bugs in constantly
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "41",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kim:2023:ESA,
  author =       "Jinhan Kim and Robert Feldt and Shin Yoo",
  title =        "Evaluating Surprise Adequacy for Deep Learning System
                 Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "42:1--42:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546947",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546947",
  abstract =     "The rapid adoption of Deep Learning (DL) systems in
                 safety critical domains such as medical imaging and
                 autonomous driving urgently calls for ways to test
                 their correctness and robustness. Borrowing from the
                 concept of test adequacy in traditional \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "42",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cogo:2023:AAB,
  author =       "Filipe Roseiro Cogo and Xin Xia and Ahmed E. Hassan",
  title =        "Assessing the Alignment between the Information Needs
                 of Developers and the Documentation of Programming
                 Languages: a Case Study on {Rust}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "43:1--43:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546945",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546945",
  abstract =     "Programming language documentation refers to the set
                 of technical documents that provide application
                 developers with a description of the high-level
                 concepts of a language (e.g., manuals, tutorials, and
                 API references). Such documentation is essential to
                 support application developers in effectively using a
                 programming language. One of the challenges faced by
                 documenters (i.e., personnel that design and produce
                 documentation for a programming language) is to ensure
                 that documentation has relevant information that aligns
                 with the concrete needs of developers, defined as the
                 missing knowledge that developers acquire via voluntary
                 search. In this article, we present an automated
                 approach to support documenters in evaluating the
                 differences and similarities between the concrete
                 information need of developers and the current state of
                 documentation (a problem that we refer to as the
                 topical alignment of a programming language
                 documentation). Our approach leverages semi-supervised
                 topic modelling that uses domain knowledge to guide the
                 derivation of topics. We initially train a baseline
                 topic model from a set of Rust-related Q\&A posts. We
                 then use this baseline model to determine the
                 distribution of topic probabilities of each document of
                 the official Rust documentation. Afterwards, we assess
                 the similarities and differences between the topics of
                 the Q\&A posts and the official documentation. Our
                 results show a relatively high level of topical
                 alignment in Rust documentation. Still, information
                 about specific topics is scarce in both the Q\&A
                 websites and the documentation, particularly related
                 topics with programming niches such as network, game,
                 and database development. For other topics (e.g.,
                 related topics with language features such as structs,
                 patterns and matchings, and foreign function
                 interface), information is only available on Q\&A
                 websites while lacking in the official documentation.
                 Finally, we discuss implications for programming
                 language documenters, particularly how to leverage our
                 approach to prioritize topics that should be added to
                 the documentation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "43",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Altoyan:2023:PCR,
  author =       "Najd Altoyan and Don Batory",
  title =        "On Proving the Correctness of Refactoring Class
                 Diagrams of {MDE} Metamodels",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "44:1--44:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3549541",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3549541",
  abstract =     "Model Driven Engineering ( MDE ) is a general-purpose
                 engineering methodology to elevate system design,
                 maintenance, and analysis to corresponding activities
                 on models. Models (graphical and/or textual) of a
                 target application are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "44",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2023:SCJ,
  author =       "Chao Wang and Hao He and Uma Pal and Darko Marinov and
                 Minghui Zhou",
  title =        "Suboptimal Comments in {Java} Projects: From
                 Independent Comment Changes to Commenting Practices",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "45:1--45:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546949",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546949",
  abstract =     "High-quality source code comments are valuable for
                 software development and maintenance, however, code
                 often contains low-quality comments or lacks them
                 altogether. We name such source code comments as
                 suboptimal comments. Such suboptimal comments create
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "45",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cheng:2023:HHI,
  author =       "Jiezhu Cheng and Cuiyun Gao and Zibin Zheng",
  title =        "{HINNPerf}: Hierarchical Interaction Neural Network
                 for Performance Prediction of Configurable Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "46:1--46:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3528100",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3528100",
  abstract =     "Modern software systems are usually highly
                 configurable, providing users with customized
                 functionality through various configuration options.
                 Understanding how system performance varies with
                 different option combinations is important to determine
                 optimal \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "46",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Belgacem:2023:MLA,
  author =       "Hichem Belgacem and Xiaochen Li and Domenico Bianculli
                 and Lionel Briand",
  title =        "A Machine Learning Approach for Automated Filling of
                 Categorical Fields in Data Entry Forms",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "47:1--47:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3533021",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3533021",
  abstract =     "Users frequently interact with software systems
                 through data entry forms. However, form filling is
                 time-consuming and error-prone. Although several
                 techniques have been proposed to auto-complete or
                 pre-fill fields in the forms, they provide limited
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "47",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ding:2023:TLG,
  author =       "Zishuo Ding and Heng Li and Weiyi Shang and Tse-Hsun
                 (Peter) Chen",
  title =        "Towards Learning Generalizable Code Embeddings Using
                 Task-agnostic Graph Convolutional Networks",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "48:1--48:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542944",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542944",
  abstract =     "Code embeddings have seen increasing applications in
                 software engineering (SE) research and practice
                 recently. Despite the advances in embedding techniques
                 applied in SE research, one of the main challenges is
                 their generalizability. A recent study finds \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "48",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zohdinasab:2023:EEF,
  author =       "Tahereh Zohdinasab and Vincenzo Riccio and Alessio
                 Gambi and Paolo Tonella",
  title =        "Efficient and Effective Feature Space Exploration for
                 Testing Deep Learning Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "49:1--49:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3544792",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3544792",
  abstract =     "Assessing the quality of Deep Learning (DL) systems is
                 crucial, as they are increasingly adopted in
                 safety-critical domains. Researchers have proposed
                 several input generation techniques for DL systems.
                 While such techniques can expose failures, they do
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "49",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2023:DHS,
  author =       "Xiaoyu Sun and Xiao Chen and Li Li and Haipeng Cai and
                 John Grundy and Jordan Samhi and Tegawend{\'e}
                 Bissyand{\'e} and Jacques Klein",
  title =        "Demystifying Hidden Sensitive Operations in {Android}
                 Apps",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "50:1--50:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3574158",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3574158",
  abstract =     "Security of Android devices is now paramount, given
                 their wide adoption among consumers. As researchers
                 develop tools for statically or dynamically detecting
                 suspicious apps, malware writers regularly update their
                 attack mechanisms to hide malicious \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "50",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Araujo:2023:TVV,
  author =       "Hugo Araujo and Mohammad Reza Mousavi and Mahsa
                 Varshosaz",
  title =        "Testing, Validation, and Verification of Robotic and
                 Autonomous Systems: a Systematic Review",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "51:1--51:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542945",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542945",
  abstract =     "We perform a systematic literature review on testing,
                 validation, and verification of robotic and autonomous
                 systems (RAS). The scope of this review covers
                 peer-reviewed research papers proposing, improving, or
                 evaluating testing techniques, processes, or \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "51",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fioraldi:2023:DAFa,
  author =       "Andrea Fioraldi and Alessandro Mantovani and Dominik
                 Maier and Davide Balzarotti",
  title =        "Dissecting {American} Fuzzy Lop: a {FuzzBench}
                 Evaluation",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "52:1--52:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580596",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580596",
  abstract =     "AFL is one of the most used and extended fuzzers,
                 adopted by industry and academic researchers alike.
                 Although the community agrees on AFL's effectiveness at
                 discovering new vulnerabilities and its outstanding
                 usability, many of its internal design \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "52",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:FCPa,
  author =       "Zenong Zhang and George Klees and Eric Wang and
                 Michael Hicks and Shiyi Wei",
  title =        "Fuzzing Configurations of Program Options",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "53:1--53:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580597",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580597",
  abstract =     "While many real-world programs are shipped with
                 configurations to enable/disable functionalities,
                 fuzzers have mostly been applied to test single
                 configurations of these programs. In this work, we
                 first conduct an empirical study to understand how
                 program \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "53",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fioraldi:2023:DAFb,
  author =       "Andrea Fioraldi and Alessandro Mantovani and Dominik
                 Maier and Davide Balzarotti",
  title =        "Dissecting {American Fuzzy Lop} --- a {FuzzBench}
                 Evaluation --- {RCR} Report",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "54:1--54:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580600",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580600",
  abstract =     "This report describes the artifacts of the
                 ``Dissecting American Fuzzy Lop --- A FuzzBench
                 Evaluation'' paper. The artifacts are available online
                 at and archived at \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "54",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:FCPb,
  author =       "Zenong Zhang and George Klees and Eric Wang and
                 Michael Hicks and Shiyi Wei",
  title =        "Fuzzing Configurations of Program Options --- {RCR}
                 Report",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "2",
  pages =        "55:1--55:??",
  month =        apr,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580601",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Apr 17 12:10:06 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580601",
  abstract =     "This artifact contains the source code and
                 instructions to reproduce the evaluation results of the
                 article ``Fuzzing Configurations of Program Options.''
                 The source code includes the configuration grammars for
                 six target programs, the scripts to generate \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "55",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cruz-Carlon:2023:PLB,
  author =       "Juan Cruz-Carlon and Mahsa Varshosaz and Claire {Le
                 Goues} and Andrzej Wasowski",
  title =        "Patching Locking Bugs Statically with Crayons",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "56:1--56:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3548684",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/linux.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3548684",
  abstract =     "The Linux Kernel is a world-class operating system
                 controlling most of our computing infrastructure:
                 mobile devices, Internet routers and services, and most
                 of the supercomputers. Linux is also an example of
                 low-level software with no comprehensive regression
                 test suite (for good reasons). The kernel's tremendous
                 societal importance imposes strict stability and
                 correctness requirements. These properties make Linux a
                 challenging and relevant target for static automated
                 program repair (APR).\par

                 Over the past decade, a significant progress has been
                 made in dynamic APR. However, dynamic APR techniques do
                 not translate naturally to systems without tests. We
                 present a static APR technique addressing sequential
                 locking API misuse bugs in the Linux Kernel. We attack
                 the key challenge of static APR, namely, the lack of
                 detailed program specification, by combining static
                 analysis with machine learning to complement the
                 information presented by the static analyzer. In
                 experiments on historical real-world bugs in the
                 kernel, we were able to automatically re-produce or
                 propose equivalent patches in 85\% of the human-made
                 patches, and automatically rank them among the top
                 three candidates for 64\% of the cases and among the
                 top five for 74\%.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "56",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ayub:2023:SSA,
  author =       "Maha Ayub and Tania Saleem and Muhammad Janjua and
                 Talha Ahmad",
  title =        "Storage State Analysis and Extraction of {Ethereum}
                 Blockchain Smart Contracts",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "57:1--57:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3548683",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3548683",
  abstract =     "In migrating and upgrading an Ethereum smart contract,
                 it is necessary to transfer both the code as well as
                 the stored data. Various methods attempt to migrate or
                 upgrade a smart contract, but they are mostly manual,
                 error-prone, and applicable only \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "57",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Laurent:2023:PCT,
  author =       "Thomas Laurent and Stefan Klikovits and Paolo Arcaini
                 and Fuyuki Ishikawa and Anthony Ventresque",
  title =        "Parameter Coverage for Testing of Autonomous Driving
                 Systems under Uncertainty",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "58:1--58:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3550270",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3550270",
  abstract =     "Autonomous Driving Systems (ADSs) are promising, but
                 must show they are secure and trustworthy before
                 adoption. Simulation-based testing is a widely adopted
                 approach, where the ADS is run in a simulated
                 environment over specific scenarios. Coverage
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "58",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pacheco:2023:MTD,
  author =       "Michael Pacheco and Gustavo Oliva and Gopi Krishnan
                 Rajbahadur and Ahmed Hassan",
  title =        "Is My Transaction Done Yet? {An} Empirical Study of
                 Transaction Processing Times in the {Ethereum}
                 Blockchain Platform",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "59:1--59:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3549542",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3549542",
  abstract =     "Ethereum is one of the most popular platforms for the
                 development of blockchain-powered applications. These
                 applications are known as {\Eth}Apps. When engineering
                 {\Eth}Apps, developers need to translate requests
                 captured in the front-end of their application into
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "59",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Patnaik:2023:SSS,
  author =       "Nikhil Patnaik and Andrew Dwyer and Joseph Hallett and
                 Awais Rashid",
  title =        "{SLR}: From {Saltzer} and {Schroeder} to 2021 \ldots{}
                 47 Years of Research on the Development and Validation
                 of Security {API} Recommendations",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "60:1--60:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3561383",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3561383",
  abstract =     "Producing secure software is challenging. The poor
                 usability of security Application Programming
                 Interfaces (APIs) makes this even harder. Many
                 recommendations have been proposed to support
                 developers by improving the usability of cryptography
                 libraries-. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "60",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ma:2023:PPR,
  author =       "Fuchen Ma and Meng Ren and Lerong Ouyang and Yuanliang
                 Chen and Juan Zhu and Ting Chen and Yingli Zheng and
                 Xiao Dai and Yu Jiang and Jiaguang Sun",
  title =        "Pied-Piper: Revealing the Backdoor Threats in
                 {Ethereum} {ERC} Token Contracts",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "61:1--61:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3560264",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3560264",
  abstract =     "With the development of decentralized networks, smart
                 contracts, especially those for ERC tokens, are
                 attracting more and more Dapp users to implement their
                 applications. There are some functions in ERC token
                 contracts that only a specific group of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "61",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:PQA,
  author =       "Yedi Zhang and Zhe Zhao and Guangke Chen and Fu Song
                 and Taolue Chen",
  title =        "Precise Quantitative Analysis of Binarized Neural
                 Networks: a {BDD}-based Approach",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "62:1--62:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3563212",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563212",
  abstract =     "As a new programming paradigm, neural-network-based
                 machine learning has expanded its application to many
                 real-world problems. Due to the black-box nature of
                 neural networks, verifying and explaining their
                 behavior are becoming increasingly important,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "62",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Perez:2023:HQM,
  author =       "Francisca P{\'e}rez and Ra{\'u}l Lape{\~n}a and Ana
                 Marc{\'e}n and Carlos Cetina",
  title =        "How the Quality of Maintenance Tasks is Affected by
                 Criteria for Selecting Engineers for Collaboration",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "63:1--63:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3561384",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3561384",
  abstract =     "In industry, software projects might span over
                 decades, with many engineers joining or leaving the
                 company over time. In these circumstances, no single
                 engineer has all of the knowledge when maintenance
                 tasks such as Traceability Link Recovery (TLR), Bug
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "63",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lopez:2023:SRS,
  author =       "Tamara Lopez and Helen Sharp and Arosha Bandara and
                 Thein Tun and Mark Levine and Bashar Nuseibeh",
  title =        "Security Responses in Software Development",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "64:1--64:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3563211",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563211",
  abstract =     "The pressure on software developers to produce secure
                 software has never been greater. But what does security
                 look like in environments that do not produce
                 security-critical software? In answer to this question,
                 this multi-sited ethnographic study \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "64",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2023:SWE,
  author =       "Deheng Yang and Yan Lei and Xiaoguang Mao and Yuhua Qi
                 and Xin Yi",
  title =        "Seeing the Whole Elephant: Systematically
                 Understanding and Uncovering Evaluation Biases in
                 Automated Program Repair",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "65:1--65:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3561382",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3561382",
  abstract =     "Evaluation is the foundation of automated program
                 repair (APR), as it provides empirical evidence on
                 strengths and weaknesses of APR techniques. However,
                 the reliability of such evaluation is often threatened
                 by various introduced biases. Consequently, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "65",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2023:AFP,
  author =       "Chengpeng Wang and Wenyang Wang and Peisen Yao and
                 Qingkai Shi and Jinguo Zhou and Xiao Xiao and Charles
                 Zhang",
  title =        "{Anchor}: Fast and Precise Value-flow Analysis for
                 Containers via Memory Orientation",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "66:1--66:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3565800",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3565800",
  abstract =     "Containers are ubiquitous data structures that support
                 a variety of manipulations on the elements, inducing
                 the indirect value flows in the program. Tracking value
                 flows through containers is stunningly difficult,
                 because it depends on container memory \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "66",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{DiSorbo:2023:AIQ,
  author =       "Andrea {Di Sorbo} and Fiorella Zampetti and Aaron
                 Visaggio and Massimiliano {Di Penta} and Sebastiano
                 Panichella",
  title =        "Automated Identification and Qualitative
                 Characterization of Safety Concerns Reported in {UAV}
                 Software Platforms",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "67:1--67:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3564821",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3564821",
  abstract =     "Unmanned Aerial Vehicles (UAVs) are nowadays used in a
                 variety of applications. Given the cyber-physical
                 nature of UAVs, software defects in these systems can
                 cause issues with safety-critical implications. An
                 important aspect of the lifecycle of UAV \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "67",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:DPA,
  author =       "Tao Chen and Miqing Li",
  title =        "Do Performance Aspirations Matter for Guiding Software
                 Configuration Tuning? {An} Empirical Investigation
                 under Dual Performance Objectives",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "68:1--68:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571853",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571853",
  abstract =     "Configurable software systems can be tuned for better
                 performance. Leveraging on some Pareto optimizers,
                 recent work has shifted from tuning for a single,
                 time-related performance objective to two intrinsically
                 different objectives that assess distinct \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "68",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gong:2023:WIU,
  author =       "Lina Gong and Jingxuan Zhang and Mingqiang Wei and
                 Haoxiang Zhang and Zhiqiu Huang",
  title =        "What Is the Intended Usage Context of This Model? {An}
                 Exploratory Study of Pre-Trained Models on Various
                 Model Repositories",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "69:1--69:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569934",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569934",
  abstract =     "There is a trend of researchers and practitioners to
                 directly apply pre-trained models to solve their
                 specific tasks. For example, researchers in software
                 engineering (SE) have successfully exploited the
                 pre-trained language models to automatically \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "69",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Karanikolas:2023:SSE,
  author =       "Chris Karanikolas and Grigoris Dimitroulakos and
                 Konstantinos Masselos",
  title =        "Simulating Software Evolution to Evaluate the
                 Reliability of Early Decision-making among Design
                 Alternatives toward Maintainability",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "70:1--70:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569931",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569931",
  abstract =     "Critical decisions among design altern seventh atives
                 with regards to maintainability arise early in the
                 software design cycle. Existing comparison models
                 relayed on the structural evolution of the used design
                 patterns are suitable to support such \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "70",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lin:2023:RRT,
  author =       "Jun-Wei Lin and Navid Salehnamadi and Sam Malek",
  title =        "Route: Roads Not Taken in {UI} Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "71:1--71:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571851",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571851",
  abstract =     "Core features (functionalities) of an app can often be
                 accessed and invoked in several ways, i.e., through
                 alternative sequences of user-interface (UI)
                 interactions. Given the manual effort of writing tests,
                 developers often only consider the typical way
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "71",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:EBB,
  author =       "Zhichao Chen and Junjie Chen and Weijing Wang and
                 Jianyi Zhou and Meng Wang and Xiang Chen and Shan Zhou
                 and Jianmin Wang",
  title =        "Exploring Better Black-{Box} Test Case Prioritization
                 via Log Analysis",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "72:1--72:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569932",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569932",
  abstract =     "Test case prioritization (TCP) has been widely studied
                 in regression testing, which aims to optimize the
                 execution order of test cases so as to detect more
                 faults earlier. TCP has been divided into white-box
                 test case prioritization (WTCP) and black-box
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "72",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zampetti:2023:CID,
  author =       "Fiorella Zampetti and Damian Tamburri and Sebastiano
                 Panichella and Annibale Panichella and Gerardo Canfora
                 and Massimiliano {Di Penta}",
  title =        "Continuous Integration and Delivery Practices for
                 Cyber-Physical Systems: an Interview-Based Study",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "73:1--73:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571854",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571854",
  abstract =     "Continuous Integration and Delivery (CI/CD) practices
                 have shown several benefits for software development
                 and operations, such as faster release cycles and early
                 discovery of defects. For Cyber-Physical System (CPS)
                 development, CI/CD can help achieving \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "73",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Verwijs:2023:TST,
  author =       "Christiaan Verwijs and Daniel Russo",
  title =        "A Theory of {Scrum} Team Effectiveness",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "74:1--74:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571849",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571849",
  abstract =     "Scrum teams are at the heart of the Scrum framework.
                 Nevertheless, an integrated and systemic theory that
                 can explain what makes some Scrum teams more effective
                 than others is still missing. To address this gap, we
                 performed a 7-year-long mixed-methods \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "74",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nass:2023:SBW,
  author =       "Michel Nass and Emil Al{\'e}groth and Robert Feldt and
                 Maurizio Leotta and Filippo Ricca",
  title =        "Similarity-based {Web} Element Localization for Robust
                 Test Automation",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "75:1--75:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571855",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571855",
  abstract =     "Non-robust (fragile) test execution is a commonly
                 reported challenge in GUI-based test automation,
                 despite much research and several proposed solutions. A
                 test script needs to be resilient to (minor) changes in
                 the tested application but, at the same time,.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "75",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Brun:2023:BPJ,
  author =       "Yuriy Brun and Tian Lin and Jessie Elise Somerville
                 and Elisha M. Myers and Natalie Ebner",
  title =        "Blindspots in {Python} and {Java} {APIs} Result in
                 Vulnerable Code",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "76:1--76:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571850",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571850",
  abstract =     "Blindspots in APIs can cause software engineers to
                 introduce vulnerabilities, but such blindspots are,
                 unfortunately, common. We study the effect APIs with
                 blindspots have on developers in two languages by
                 replicating a 109-developer, 24-Java-API \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "76",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2023:RCN,
  author =       "Eric S. Liu and Dylan A. Lukes and William G.
                 Griswold",
  title =        "Refactoring in Computational Notebooks",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "77:1--77:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576036",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576036",
  abstract =     "Due to the exploratory nature of computational
                 notebook development, a notebook can be extensively
                 evolved even though it is small, potentially incurring
                 substantial technical debt. Indeed, in interview
                 studies notebook authors have attested to performing
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "77",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:IGL,
  author =       "Zhuo Zhang and Yan Lei and Ting Su and Meng Yan and
                 Xiaoguang Mao and Yue Yu",
  title =        "Influential Global and Local Contexts Guided Trace
                 Representation for Fault Localization",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "78:1--78:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576043",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576043",
  abstract =     "Trace data is critical for fault localization (FL) to
                 analyze suspicious statements potentially responsible
                 for a failure. However, existing trace representation
                 meets its bottleneck mainly in two aspects: (1) the
                 trace information of a statement is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "78",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Attaoui:2023:BBS,
  author =       "Mohammed Attaoui and Hazem Fahmy and Fabrizio Pastore
                 and Lionel Briand",
  title =        "Black-box Safety Analysis and Retraining of {DNNs}
                 based on Feature Extraction and Clustering",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "79:1--79:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3550271",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3550271",
  abstract =     "Deep neural networks (DNNs) have demonstrated superior
                 performance over classical machine learning to support
                 many features in safety-critical systems. Although DNNs
                 are now widely used in such systems (e.g., self driving
                 cars), there is limited progress \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "79",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2023:KWY,
  author =       "Zhipeng Gao and Xin Xia and David Lo and John Grundy
                 and Xindong Zhang and Zhenchang Xing",
  title =        "{I} Know What You Are Searching for: Code Snippet
                 Recommendation from {Stack Overflow} Posts",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "80:1--80:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3550150",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3550150",
  abstract =     "Stack Overflow has been heavily used by software
                 developers to seek programming-related information.
                 More and more developers use Community Question and
                 Answer forums, such as Stack Overflow, to search for
                 code examples of how to accomplish a certain \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "80",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dola:2023:IDC,
  author =       "Swaroopa Dola and Matthew B. Dwyer and Mary Lou
                 Soffa",
  title =        "Input Distribution Coverage: Measuring Feature
                 Interaction Adequacy in Neural Network Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "3",
  pages =        "81:1--81:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576040",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 9 06:39:39 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576040",
  abstract =     "Testing deep neural networks (DNNs) has garnered great
                 interest in the recent years due to their use in many
                 applications. Black-box test adequacy measures are
                 useful for guiding the testing process in covering the
                 input domain. However, the absence of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "81",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cui:2023:SDM,
  author =       "Mohan Cui and Chengjun Chen and Hui Xu and Yangfan
                 Zhou",
  title =        "{SafeDrop}: Detecting Memory Deallocation Bugs of
                 {Rust} Programs via Static Data-flow Analysis",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "82:1--82:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3542948",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3542948",
  abstract =     "Rust is an emerging programming language that aims to
                 prevent memory-safety bugs. However, the current design
                 of Rust also brings side effects, which may increase
                 the risk of memory-safety issues. In particular, it
                 employs ownership-based resource \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "82",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shreeve:2023:MSU,
  author =       "Benjamin Shreeve and Catarina Gralha and Awais Rashid
                 and Jo{\~a}o Ara{\'u}jo and Miguel Goul{\~a}o",
  title =        "Making Sense of the Unknown: How Managers Make Cyber
                 Security Decisions",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "83:1--83:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3548682",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3548682",
  abstract =     "Managers rarely have deep knowledge of cyber security
                 and yet are expected to make decisions with cyber
                 security implications for software-based systems. We
                 investigate the decision-making conversations of seven
                 teams of senior managers from the same \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "83",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ghorbani:2023:DDD,
  author =       "Negar Ghorbani and Reyhaneh Jabbarvand and Navid
                 Salehnamadi and Joshua Garcia and Sam Malek",
  title =        "{DeltaDroid}: Dynamic Delivery Testing in {Android}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "84:1--84:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3563213",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563213",
  abstract =     "Android is a highly fragmented platform with a diverse
                 set of devices and users. To support the deployment of
                 apps in such a heterogeneous setting, Android has
                 introduced dynamic delivery -a new model of software
                 deployment in which optional, device- or \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "84",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sohn:2023:ASB,
  author =       "Jeongju Sohn and Sungmin Kang and Shin Yoo",
  title =        "{Arachne}: Search-Based Repair of Deep Neural
                 Networks",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "85:1--85:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3563210",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563210",
  abstract =     "The rapid and widespread adoption of Deep Neural
                 Networks (DNNs) has called for ways to test their
                 behaviour, and many testing approaches have
                 successfully revealed misbehaviour of DNNs. However, it
                 is relatively unclear what one can do to correct such
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "85",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Joblin:2023:HHO,
  author =       "Mitchell Joblin and Barbara Eckl and Thomas Bock and
                 Angelika Schmid and Janet Siegmund and Sven Apel",
  title =        "Hierarchical and Hybrid Organizational Structures in
                 Open-source Software Projects: a Longitudinal Study",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "86:1--86:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569949",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569949",
  abstract =     "Despite the absence of a formal process and a central
                 command-and-control structure, developer organization
                 in open-source software (OSS) projects are far from
                 being a purely random process. Prior work indicates
                 that, over time, highly successful OSS \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "86",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jia:2023:IEF,
  author =       "Ang Jia and Ming Fan and Wuxia Jin and Xi Xu and
                 Zhaohui Zhou and Qiyi Tang and Sen Nie and Shi Wu and
                 Ting Liu",
  title =        "$1$-to-$1$ or $1$-to-$n$? {Investigating} the Effect
                 of Function Inlining on Binary Similarity Analysis",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "87:1--87:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3561385",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3561385",
  abstract =     "Binary similarity analysis is critical to many
                 code-reuse-related issues, where function matching is
                 its fundamental task. ``1-to-1'' mechanism has been
                 applied in most binary similarity analysis works, in
                 which one function in a binary file is matched
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "87",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nardone:2023:VGB,
  author =       "Vittoria Nardone and Biruk Muse and Mouna Abidi and
                 Foutse Khomh and Massimiliano {Di Penta}",
  title =        "Video Game Bad Smells: What They Are and How
                 Developers Perceive Them",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "88:1--88:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3563214",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563214",
  abstract =     "Video games represent a substantial and increasing
                 share of the software market. However, their
                 development is particularly challenging as it requires
                 multi-faceted knowledge, which is not consolidated in
                 computer science education yet. This article aims
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "88",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:DDA,
  author =       "Xueling Zhang and John Heaps and Rocky Slavin and
                 Jianwei Niu and Travis Breaux and Xiaoyin Wang",
  title =        "{DAISY}: Dynamic-Analysis-Induced Source Discovery for
                 Sensitive Data",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "89:1--89:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569936",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569936",
  abstract =     "Mobile apps are widely used and often process users'
                 sensitive data. Many taint analysis tools have been
                 applied to analyze sensitive information flows and
                 report data leaks in apps. These tools require a list
                 of sources (where sensitive data is accessed)
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "89",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2023:SSA,
  author =       "Huaijin Wang and Pingchuan Ma and Shuai Wang and Qiyi
                 Tang and Sen Nie and Shi Wu",
  title =        "{\tt sem2vec}: Semantics-aware Assembly Tracelet
                 Embedding",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "90:1--90:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569933",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569933",
  abstract =     "Binary code similarity is the foundation of many
                 security and software engineering applications. Recent
                 works leverage deep neural networks (DNN) to learn a
                 numeric vector representation (namely, embeddings ) of
                 assembly functions, enabling similarity \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "90",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Alfadel:2023:DNV,
  author =       "Mahmoud Alfadel and Diego Elias Costa and Emad Shihab
                 and Bram Adams",
  title =        "On the Discoverability of npm Vulnerabilities in
                 {\tt Node.js} Projects",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "91:1--91:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571848",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571848",
  abstract =     "The reliance on vulnerable dependencies is a major
                 threat to software systems. Dependency vulnerabilities
                 are common and remain undisclosed for years. However,
                 once the vulnerability is discovered and publicly known
                 to the community, the risk of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "91",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tian:2023:BBW,
  author =       "Haoye Tian and Kui Liu and Yinghua Li and Abdoul Kader
                 Kabor{\'e} and Anil Koyuncu and Andrew Habib and Li Li
                 and Junhao Wen and Jacques Klein and Tegawend{\'e} F.
                 Bissyand{\'e}",
  title =        "The Best of Both Worlds: Combining Learned Embeddings
                 with Engineered Features for Accurate Prediction of
                 Correct Patches",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "92:1--92:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576039",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576039",
  abstract =     "A large body of the literature on automated program
                 repair develops approaches where patches are
                 automatically generated to be validated against an
                 oracle (e.g., a test suite). Because such an oracle can
                 be imperfect, the generated patches, although
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "92",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jin:2023:HCB,
  author =       "Xianhao Jin and Francisco Servant",
  title =        "{HybridCISave}: a Combined Build and Test Selection
                 Approach in Continuous Integration",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "93:1--93:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576038",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576038",
  abstract =     "Continuous Integration (CI) is a popular practice in
                 modern software engineering. Unfortunately, it is also
                 a high-cost practice-Google and Mozilla estimate their
                 CI systems in millions of dollars. To reduce the
                 computational cost in CI, researchers \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "93",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Venturini:2023:DYY,
  author =       "Daniel Venturini and Filipe Roseiro Cogo and Ivanilton
                 Polato and Marco A. Gerosa and Igor Scaliante Wiese",
  title =        "{I} Depended on You and You Broke Me: an Empirical
                 Study of Manifesting Breaking Changes in Client
                 Packages",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "94:1--94:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576037",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576037",
  abstract =     "Complex software systems have a network of
                 dependencies. Developers often configure package
                 managers (e.g., npm) to automatically update
                 dependencies with each publication of new releases
                 containing bug fixes and new features. When a
                 dependency release \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "94",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Han:2023:UAR,
  author =       "Liping Han and Shaukat Ali and Tao Yue and Aitor
                 Arrieta and Maite Arratibel",
  title =        "Uncertainty-Aware Robustness Assessment of Industrial
                 Elevator Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "95:1--95:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576041",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576041",
  abstract =     "Industrial elevator systems are commonly used software
                 systems in our daily lives, which operate in uncertain
                 environments such as unpredictable passenger traffic,
                 uncertain passenger attributes and behaviors, and
                 hardware delays. Understanding and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "95",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2023:RFP,
  author =       "Kui Liu and Jingtang Zhang and Li Li and Anil Koyuncu
                 and Dongsun Kim and Chunpeng Ge and Zhe Liu and Jacques
                 Klein and Tegawend{\'e} F. Bissyand{\'e}",
  title =        "Reliable Fix Patterns Inferred from Static Checkers
                 for Automated Program Repair",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "96:1--96:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579637",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579637",
  abstract =     "Fix pattern-based patch generation is a promising
                 direction in automated program repair (APR). Notably,
                 it has been demonstrated to produce more acceptable and
                 correct patches than the patches obtained with mutation
                 operators through genetic programming. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "96",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:DBR,
  author =       "Ting Zhang and Donggyun Han and Venkatesh Vinayakarao
                 and Ivana Clairine Irsan and Bowen Xu and Ferdian Thung
                 and David Lo and Lingxiao Jiang",
  title =        "Duplicate Bug Report Detection: How Far Are We?",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "97:1--97:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3576042",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3576042",
  abstract =     "Many Duplicate Bug Report Detection (DBRD) techniques
                 have been proposed in the research literature. The
                 industry uses some other techniques. Unfortunately,
                 there is insufficient comparison among them, and it is
                 unclear how far we have been. This work \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "97",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhu:2023:CSU,
  author =       "Chenguang Zhu and Mengshi Zhang and Xiuheng Wu and
                 Xiufeng Xu and Yi Li",
  title =        "Client-Specific Upgrade Compatibility Checking via
                 Knowledge-Guided Discovery",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "98:1--98:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582569",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582569",
  abstract =     "Modern software systems are complex, and they heavily
                 rely on external libraries developed by different teams
                 and organizations. Such systems suffer from higher
                 instability due to incompatibility issues caused by
                 library upgrades. In this article, we \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "98",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rahman:2023:SMO,
  author =       "Akond Rahman and Shazibul Islam Shamim and Dibyendu
                 Brinto Bose and Rahul Pandita",
  title =        "Security Misconfigurations in Open Source {Kubernetes}
                 Manifests: an Empirical Study",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "99:1--99:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579639",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579639",
  abstract =     "Context: Kubernetes has emerged as the de-facto tool
                 for automated container orchestration. Business and
                 government organizations are increasingly adopting
                 Kubernetes for automated software deployments.
                 Kubernetes is being used to provision applications
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "99",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sintaha:2023:KDS,
  author =       "Mifta Sintaha and Noor Nashid and Ali Mesbah",
  title =        "{Katana}: Dual Slicing Based Context for Learning Bug
                 Fixes",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "100:1--100:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579640",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579640",
  abstract =     "Contextual information plays a vital role for software
                 developers when understanding and fixing a bug.
                 Consequently, deep learning based program repair
                 techniques leverage context for bug fixes. However,
                 existing techniques treat context in an arbitrary
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "100",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{He:2023:IBC,
  author =       "Dongjie He and Jingbo Lu and Jingling Xue",
  title =        "{IFDS}-based Context Debloating for Object-Sensitive
                 Pointer Analysis",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "101:1--101:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579641",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579641",
  abstract =     "Object-sensitive pointer analysis, which separates the
                 calling contexts of a method by its receiver objects,
                 is known to achieve highly useful precision for
                 object-oriented languages such as Java. Despite recent
                 advances, all object-sensitive pointer \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "101",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2023:CLL,
  author =       "Zhaoqiang Guo and Shiran Liu and Xutong Liu and Wei
                 Lai and Mingliang Ma and Xu Zhang and Chao Ni and
                 Yibiao Yang and Yanhui Li and Lin Chen and Guoqiang
                 Zhou and Yuming Zhou",
  title =        "Code-line-level Bugginess Identification: How Far have
                 We Come, and How Far have We Yet to Go?",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "102:1--102:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582572",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582572",
  abstract =     "Background. Code-line-level bugginess identification
                 (CLBI) is a vital technique that can facilitate
                 developers to identify buggy lines without expending a
                 large amount of human effort. Most of the existing
                 studies tried to mine the characteristics of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "102",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yu:2023:STQ,
  author =       "Nengkun Yu",
  title =        "Structured Theorem for Quantum Programs and its
                 Applications",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "103:1--103:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587154",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587154",
  abstract =     "This article proves a structured program theorem for
                 flowchart quantum programs. The theorem states that any
                 flowchart quantum program is equivalent to a single
                 quantum program that repeatedly executes a quantum
                 measurement and a subprogram, so long as \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "103",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fahmy:2023:SBE,
  author =       "Hazem Fahmy and Fabrizio Pastore and Lionel Briand and
                 Thomas Stifter",
  title =        "Simulator-based Explanation and Debugging of
                 Hazard-triggering Events in {DNN}-based Safety-critical
                 Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "104:1--104:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3569935",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3569935",
  abstract =     "When Deep Neural Networks (DNNs) are used in
                 safety-critical systems, engineers should determine the
                 safety risks associated with failures (i.e., erroneous
                 outputs) observed during testing. For DNNs processing
                 images, engineers visually inspect all \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "104",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Braiek:2023:TFN,
  author =       "Houssem {Ben Braiek} and Foutse Khomh",
  title =        "Testing Feedforward Neural Networks Training
                 Programs",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "105:1--105:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3529318",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3529318",
  abstract =     "At present, we are witnessing an increasing effort to
                 improve the performance and trustworthiness of Deep
                 Neural Networks (DNNs), with the aim to enable their
                 adoption in safety critical systems such as
                 self-driving cars or aircraft collision-avoidance
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "105",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:CES,
  author =       "Zhenpeng Chen and Jie M. Zhang and Federica Sarro and
                 Mark Harman",
  title =        "A Comprehensive Empirical Study of Bias Mitigation
                 Methods for Machine Learning Classifiers",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "106:1--106:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583561",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583561",
  abstract =     "Software bias is an increasingly important operational
                 concern for software engineers. We present a
                 large-scale, comprehensive empirical study of 17
                 representative bias mitigation methods for Machine
                 Learning (ML) classifiers, evaluated with 11 ML
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "106",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Badampudi:2023:MCR,
  author =       "Deepika Badampudi and Michael Unterkalmsteiner and
                 Ricardo Britto",
  title =        "Modern Code Reviews --- Survey of Literature and
                 Practice",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "4",
  pages =        "107:1--107:??",
  month =        jul,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585004",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Jul 3 08:45:48 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585004",
  abstract =     "Background: Modern Code Review (MCR) is a lightweight
                 alternative to traditional code inspections. While
                 secondary studies on MCR exist, it is u a nknown
                 whether the research community has targeted themes that
                 practitioners consider important. Objectives:
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "107",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hidellaarachchi:2023:IHA,
  author =       "Dulaji Hidellaarachchi and John Grundy and Rashina
                 Hoda and Ingo Mueller",
  title =        "The Influence of Human Aspects on Requirements
                 Engineering-related Activities: Software Practitioners'
                 Perspective",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "108:1--108:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3546943",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3546943",
  abstract =     "Requirements Engineering (RE)-related activities
                 require high collaboration between various roles in
                 software engineering (SE), such as requirements
                 engineers, stakeholders, developers, and so on. Their
                 demographics, views, understanding of technologies,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "108",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2023:RAK,
  author =       "Di Wu and Xiao-Yuan Jing and Hongyu Zhang and Yang
                 Feng and Haowen Chen and Yuming Zhou and Baowen Xu",
  title =        "Retrieving {API} Knowledge from Tutorials and {Stack
                 Overflow} Based on Natural Language Queries",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "109:1--109:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3565799",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3565799",
  abstract =     "When encountering unfamiliar APIs, developers tend to
                 seek help from API tutorials and Stack Overflow (SO).
                 API tutorials help developers understand the API
                 knowledge in a general context, while SO often explains
                 the API knowledge in a specific \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "109",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wolter:2023:OSL,
  author =       "Thomas Wolter and Ann Barcomb and Dirk Riehle and
                 Nikolay Harutyunyan",
  title =        "Open Source License Inconsistencies on {GitHub}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "110:1--110:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571852",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571852",
  abstract =     "Almost all software, open or closed, builds on open
                 source software and therefore needs to comply with the
                 license obligations of the open source code. Not
                 knowing which licenses to comply with poses a legal
                 danger to anyone using open source software. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "110",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Muller:2023:CWH,
  author =       "Katharina M{\"u}ller and Christian Koch and Dirk
                 Riehle and Michael Stops and Nikolay Harutyunyan",
  title =        "Challenges of Working from Home in Software
                 Development During {Covid-19} Lockdowns",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "111:1--111:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579636",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579636",
  abstract =     "The COVID-19 pandemic in 2020/2021/2022 and the
                 resulting lockdowns forced many companies to switch to
                 working from home, swiftly, on a large scale, and
                 without preparation. This situation created unique
                 challenges for software development, where \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "111",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yitagesu:2023:EPB,
  author =       "Sofonias Yitagesu and Zhenchang Xing and Xiaowang
                 Zhang and Zhiyong Feng and Xiaohong Li and Linyi Han",
  title =        "Extraction of Phrase-based Concepts in Vulnerability
                 Descriptions through Unsupervised Labeling",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "112:1--112:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579638",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579638",
  abstract =     "Software vulnerabilities, once disclosed, can be
                 documented in vulnerability databases, which have great
                 potential to advance vulnerability analysis and
                 security research. People describe the key
                 characteristics of software vulnerabilities in natural
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "112",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2023:DTB,
  author =       "Qinghua Xu and Shaukat Ali and Tao Yue",
  title =        "Digital Twin-based Anomaly Detection with Curriculum
                 Learning in Cyber-physical Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "113:1--113:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582571",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582571",
  abstract =     "Anomaly detection is critical to ensure the security
                 of cyber-physical systems (CPS). However, due to the
                 increasing complexity of attacks and CPS themselves,
                 anomaly detection in CPS is becoming more and more
                 challenging. In our previous work, we \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "113",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lavazza:2023:ESF,
  author =       "Luigi Lavazza and Angela Locoro and Geng Liu and
                 Roberto Meli",
  title =        "Estimating Software Functional Size via Machine
                 Learning",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "114:1--114:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582575",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582575",
  abstract =     "Measuring software functional size via standard
                 Function Points Analysis (FPA) requires the
                 availability of fully specified requirements and
                 specific competencies. Most of the time, the need to
                 measure software functional size occurs well in advance
                 with \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "114",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2023:TIG,
  author =       "Jia Yang and Cai Fu and Fengyang Deng and Ming Wen and
                 Xiaowei Guo and Chuanhao Wan",
  title =        "Toward Interpretable Graph Tensor Convolution Neural
                 Network for Code Semantics Embedding",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "115:1--115:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582574",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582574",
  abstract =     "Intelligent deep learning-based models have made
                 significant progress for automated source code
                 semantics embedding, and current research works mainly
                 leverage natural language-based methods and graph-based
                 methods. However, natural language-based methods
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "115",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{C:2023:AEB,
  author =       "Shrikanth N. C. and Tim Menzies",
  title =        "Assessing the Early Bird Heuristic (for Predicting
                 Project Quality)",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "116:1--116:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583565",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583565",
  abstract =     "Before researchers rush to reason across all available
                 data or try complex methods, perhaps it is prudent to
                 first check for simpler alternatives. Specifically, if
                 the historical data has the most information in some
                 small region, then perhaps a model \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "116",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Camilli:2023:ADD,
  author =       "Matteo Camilli and Carmine Colarusso and Barbara Russo
                 and Eugenio Zimeo",
  title =        "Actor-Driven Decomposition of Microservices through
                 Multi-level Scalability Assessment",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "117:1--117:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583563",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583563",
  abstract =     "The microservices architectural style has gained
                 widespread acceptance. However, designing applications
                 according to this style is still challenging. Common
                 difficulties concern finding clear boundaries that
                 guide decomposition while ensuring performance
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "117",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sarker:2023:AIT,
  author =       "Jaydeb Sarker and Asif Kamal Turzo and Ming Dong and
                 Amiangshu Bosu",
  title =        "Automated Identification of Toxic Code Reviews Using
                 {ToxiCR}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "118:1--118:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583562",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583562",
  abstract =     "Toxic conversations during software development
                 interactions may have serious repercussions on a Free
                 and Open Source Software (FOSS) development project.
                 For example, victims of toxic conversations may become
                 afraid to express themselves, therefore get \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "118",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2023:FGA,
  author =       "Xuanzhe Liu and Jinfeng Wen and Zhenpeng Chen and Ding
                 Li and Junkai Chen and Yi Liu and Haoyu Wang and Xin
                 Jin",
  title =        "{FaaSLight}: General Application-level Cold-start
                 Latency Optimization for Function-as-a-Service in
                 Serverless Computing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "119:1--119:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585007",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585007",
  abstract =     "Serverless computing is a popular cloud computing
                 paradigm that frees developers from server management.
                 Function-as-a-Service (FaaS) is the most popular
                 implementation of serverless computing, representing
                 applications as event-driven and stateless \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "119",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Davis:2023:WWP,
  author =       "Matthew C. Davis and Emad Aghayi and Thomas D. Latoza
                 and Xiaoyin Wang and Brad A. Myers and Joshua
                 Sunshine",
  title =        "What's (Not) Working in Programmer User Studies?",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "120:1--120:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587157",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587157",
  abstract =     "A key goal of software engineering research is to
                 improve the environments, tools, languages, and
                 techniques programmers use to efficiently create
                 quality software. Successfully designing these tools
                 and demonstrating their effectiveness involves engaging
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "120",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sattler:2023:SIP,
  author =       "Florian Sattler and Sebastian B{\"o}hm and Philipp
                 Dominik Schubert and Norbert Siegmund and Sven Apel",
  title =        "{SEAL}: Integrating Program Analysis and Repository
                 Mining",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "121:1--121:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585008",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585008",
  abstract =     "Software projects are complex technical and
                 organizational systems involving large numbers of
                 artifacts and developers. To understand and tame
                 software complexity, a wide variety of program analysis
                 techniques have been developed for bug detection,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "121",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:WBF,
  author =       "Man Zhang and Andrea Arcuri and Yonggang Li and Yang
                 Liu and Kaiming Xue",
  title =        "White-Box Fuzzing {RPC}-Based {APIs} with {EvoMaster}:
                 an Industrial Case Study",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "122:1--122:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585009",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585009",
  abstract =     "Remote Procedure Call (RPC) is a communication
                 protocol to support client-server interactions among
                 services over a network. RPC is widely applied in
                 industry for building large-scale distributed systems,
                 such as Microservices. Modern RPC frameworks \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "122",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wei:2023:HTB,
  author =       "Hongwei Wei and Xiaohong Su and Cuiyun Gao and Weining
                 Zheng and Wenxin Tao",
  title =        "A Hypothesis Testing-based Framework for Software
                 Cross-modal Retrieval in Heterogeneous Semantic
                 Spaces",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "123:1--123:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3591868",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591868",
  abstract =     "Software cross-modal retrieval is a popular yet
                 challenging direction, such as bug localization and
                 code search. Previous studies generally map natural
                 language texts and codes into a homogeneous semantic
                 space for similarity measurement. However, it is
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "123",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tang:2023:SAD,
  author =       "Shuncheng Tang and Zhenya Zhang and Yi Zhang and
                 Jixiang Zhou and Yan Guo and Shuang Liu and Shengjian
                 Guo and Yan-Fu Li and Lei Ma and Yinxing Xue and Yang
                 Liu",
  title =        "A Survey on Automated Driving System Testing:
                 Landscapes and Trends",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "124:1--124:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579642",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579642",
  abstract =     "Automated Driving Systems ( ADS ) have made great
                 achievements in recent years thanks to the efforts from
                 both academia and industry. A typical ADS is composed
                 of multiple modules, including sensing, perception,
                 planning, and control, which brings together \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "124",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:QQO,
  author =       "Jialuo Chen and Jingyi Wang and Xingjun Ma and
                 Youcheng Sun and Jun Sun and Peixin Zhang and Peng
                 Cheng",
  title =        "{QuoTe}: Quality-oriented Testing for Deep Learning
                 Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "125:1--125:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582573",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582573",
  abstract =     "Recently, there has been significant growth of
                 interest in applying software engineering techniques
                 for the quality assurance of deep learning (DL)
                 systems. One popular direction is DL testing-that is,
                 given a property of test, defects of DL systems are
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "125",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2023:CSM,
  author =       "Yuan Huang and Hanyang Guo and Xi Ding and Junhuai Shu
                 and Xiangping Chen and Xiapu Luo and Zibin Zheng and
                 Xiaocong Zhou",
  title =        "A Comparative Study on Method Comment and Inline
                 Comment",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "126:1--126:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3582570",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3582570",
  abstract =     "Code comments are one of the important documents to
                 help developers review and comprehend source code. In
                 recent studies, researchers have proposed many deep
                 learning models to generate the method header comments
                 (i.e., method comment), which have \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "126",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2023:CCG,
  author =       "Meiziniu Li and Jialun Cao and Yongqiang Tian and Tsz
                 On Li and Ming Wen and Shing-Chi Cheung",
  title =        "{COMET}: Coverage-guided Model Generation For Deep
                 Learning Library Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "127:1--127:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583566",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583566",
  abstract =     "Recent deep learning (DL) applications are mostly
                 built on top of DL libraries. The quality assurance of
                 these libraries is critical to the dependable
                 deployment of DL applications. Techniques have been
                 proposed to generate various DL models and apply
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "127",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tian:2023:FDB,
  author =       "Yongqiang Tian and Wuqi Zhang and Ming Wen and
                 Shing-Chi Cheung and Chengnian Sun and Shiqing Ma and
                 Yu Jiang",
  title =        "Finding Deviated Behaviors of the Compressed {DNN}
                 Models for Image Classifications",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "128:1--128:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3583564",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583564",
  abstract =     "Model compression can significantly reduce the sizes
                 of deep neural network (DNN) models and thus facilitate
                 the dissemination of sophisticated, sizable DNN models,
                 especially for deployment on mobile or embedded
                 devices. However, the prediction results \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "128",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Qi:2023:ABL,
  author =       "Hua Qi and Zhijie Wang and Qing Guo and Jianlang Chen
                 and Felix Juefei-Xu and Fuyuan Zhang and Lei Ma and
                 Jianjun Zhao",
  title =        "{ArchRepair}: Block-Level Architecture-Oriented
                 Repairing for Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "129:1--129:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585005",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585005",
  abstract =     "Over the past few years, deep neural networks (DNNs)
                 have achieved tremendous success and have been
                 continuously applied in many application domains.
                 However, during the practical deployment in industrial
                 tasks, DNNs are found to be erroneous-prone due to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "129",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zheng:2023:SES,
  author =       "Zibin Zheng and Weili Chen and Zhijie Zhong and
                 Zhiguang Chen and Yutong Lu",
  title =        "Securing the {Ethereum} from Smart {Ponzi} Schemes:
                 Identification Using Static Features",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "130:1--130:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3571847",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3571847",
  abstract =     "Malware detection approaches have been extensively
                 studied for traditional software systems. However, the
                 development of blockchain technology has promoted the
                 birth of a new type of software system-decentralized
                 applications. Composed of smart contracts, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "130",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wen:2023:RPS,
  author =       "Jinfeng Wen and Zhenpeng Chen and Xin Jin and Xuanzhe
                 Liu",
  title =        "Rise of the Planet of Serverless Computing: a
                 Systematic Review",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "131:1--131:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3579643",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579643",
  abstract =     "Serverless computing is an emerging cloud computing
                 paradigm, being adopted to develop a wide range of
                 software applications. It allows developers to focus on
                 the application logic in the granularity of function,
                 thereby freeing developers from tedious \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "131",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Herrera:2023:DTDa,
  author =       "Adrian Herrera and Mathias Payer and Antony L.
                 Hosking",
  title =        "{DatAFLow}: Toward a Data-Flow-Guided Fuzzer",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "132:1--132:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587156",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587156",
  abstract =     "Coverage-guided greybox fuzzers rely on control-flow
                 coverage feedback to explore a target program and
                 uncover bugs. Compared to control-flow coverage,
                 data-flow coverage offers a more fine-grained
                 approximation of program behavior. Data-flow coverage
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "132",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Herrera:2023:DTDb,
  author =       "Adrian Herrera and Mathias Payer and Antony L.
                 Hosking",
  title =        "{DatAFLow}: Toward a Data-flow-guided Fuzzer",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "5",
  pages =        "133:1--133:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587159",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Aug 11 07:01:24 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587159",
  abstract =     "This Replicating Computational Report (RCR) describes
                 (a) our datAFLow fuzzer and (b) how to replicate the
                 results in ``datAFLow: Toward a Data-Flow-Guided
                 Fuzzer.'' Our primary artifact is the datAFLow fuzzer.
                 Unlike traditional coverage-guided greybox \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "133",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Majumder:2023:FES,
  author =       "Suvodeep Majumder and Joymallya Chakraborty and Gina
                 R. Bai and Kathryn T. Stolee and Tim Menzies",
  title =        "Fair Enough: Searching for Sufficient Measures of
                 Fairness",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "134:1--134:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3585006",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3585006",
  abstract =     "Testing machine learning software for ethical bias has
                 become a pressing current concern. In response, recent
                 research has proposed a plethora of new fairness
                 metrics, for example, the dozens of fairness metrics in
                 the IBM AIF360 toolkit. This raises the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "134",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2023:TUD,
  author =       "Junjie Chen and Yihua Liang and Qingchao Shen and
                 Jiajun Jiang and Shuochuan Li",
  title =        "Toward Understanding Deep Learning Framework Bugs",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "135:1--135:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587155",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587155",
  abstract =     "DL frameworks are the basis of constructing all DL
                 programs and models, and thus their bugs could lead to
                 the unexpected behaviors of any DL program or model
                 relying on them. Such a wide effect demonstrates the
                 necessity and importance of guaranteeing DL \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "135",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hassan:2023:UUF,
  author =       "Foyzul Hassan and Na Meng and Xiaoyin Wang",
  title =        "{UniLoc}: Unified Fault Localization of Continuous
                 Integration Failures",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "136:1--136:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3593799",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593799",
  abstract =     "Continuous integration (CI) practices encourage
                 developers to frequently integrate code into a shared
                 repository. Each integration is validated by automatic
                 build and testing such that errors are revealed as
                 early as possible. When CI failures or \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "136",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:TIT,
  author =       "Mengdi Zhang and Jun Sun and Jingyi Wang and Bing
                 Sun",
  title =        "{TestSGD}: Interpretable Testing of Neural Networks
                 against Subtle Group Discrimination",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "137:1--137:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3591869",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591869",
  abstract =     "Discrimination has been shown in many machine learning
                 applications, which calls for sufficient fairness
                 testing before their deployment in ethic-relevant
                 domains. One widely concerning type of discrimination,
                 testing against group discrimination, mostly \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "137",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bock:2023:ACD,
  author =       "Thomas Bock and Nils Alznauer and Mitchell Joblin and
                 Sven Apel",
  title =        "Automatic Core-Developer Identification on {GitHub}: a
                 Validation Study",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "138:1--138:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3593803",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593803",
  abstract =     "Many open-source software projects are self-organized
                 and do not maintain official lists with information on
                 developer roles. So, knowing which developers take core
                 and maintainer roles is, despite being relevant, often
                 tacit knowledge. We propose a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "138",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:JSH,
  author =       "Man Zhang and Asma Belhadi and Andrea Arcuri",
  title =        "{JavaScript SBST} Heuristics to Enable Effective
                 Fuzzing of {NodeJS} Web {APIs}",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "139:1--139:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3593801",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593801",
  abstract =     "JavaScript is one of the most popular programming
                 languages. However, its dynamic nature poses several
                 challenges to automated testing techniques. In this
                 paper, we propose an approach and open-source tool
                 support to enable white-box testing of JavaScript
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "139",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2023:XEC,
  author =       "Chong Wang and Xin Peng and Zhenchang Xing and Yue
                 Zhang and Mingwei Liu and Rong Luo and Xiujie Meng",
  title =        "{XCoS}: Explainable Code Search Based on Query Scoping
                 and Knowledge Graph",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "140:1--140:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3593800",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593800",
  abstract =     "When searching code, developers may express additional
                 constraints (e.g., functional constraints and
                 nonfunctional constraints) on the implementations of
                 desired functionalities in the queries. Existing code
                 search tools treat the queries as a whole and
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "140",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Assi:2023:PCI,
  author =       "Maram Assi and Safwat Hassan and Stefanos Georgiou and
                 Ying Zou",
  title =        "Predicting the Change Impact of Resolving Defects by
                 Leveraging the Topics of Issue Reports in Open Source
                 Software Systems",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "141:1--141:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3593802",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593802",
  abstract =     "Upon receiving a new issue report, practitioners start
                 by investigating the defect type, the potential fixing
                 effort needed to resolve the defect and the change
                 impact. Moreover, issue reports contain valuable
                 information, such as, the title, description \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "141",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rosa:2023:WQA,
  author =       "Giovanni Rosa and Simone Scalabrino and Gabriele
                 Bavota and Rocco Oliveto",
  title =        "What Quality Aspects Influence the Adoption of
                 {Docker} Images?",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "142:1--142:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3603111",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3603111",
  abstract =     "Docker is a containerization technology that allows
                 developers to ship software applications along with
                 their dependencies in Docker images. Developers can
                 extend existing images using them as base images when
                 writing Dockerfiles. However, a lot of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "142",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2023:CLE,
  author =       "Jia Li and Ge Li and Zhuo Li and Zhi Jin and Xing Hu
                 and Kechi Zhang and Zhiyi Fu",
  title =        "{CodeEditor}: Learning to Edit Source Code with
                 Pre-trained Models",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "143:1--143:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597207",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597207",
  abstract =     "Developers often perform repetitive code editing
                 activities (up to 70\%) for various reasons (e.g., code
                 refactoring) during software development. Many deep
                 learning (DL) models have been proposed to automate
                 code editing by learning from the code editing
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "143",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:OPF,
  author =       "Man Zhang and Andrea Arcuri",
  title =        "Open Problems in Fuzzing {RESTful APIs}: a Comparison
                 of Tools",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "144:1--144:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597205",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597205",
  abstract =     "RESTful APIs are a type of web service that are widely
                 used in industry. In the past few years, a lot of
                 effort in the research community has been spent in
                 designing novel techniques to automatically fuzz those
                 APIs to find faults in them. Many real \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "144",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Suneja:2023:ISA,
  author =       "Sahil Suneja and Yufan Zhuang and Yunhui Zheng and Jim
                 Laredo and Alessandro Morari and Udayan Khurana",
  title =        "Incorporating Signal Awareness in Source Code
                 Modeling: an Application to Vulnerability Detection",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "145:1--145:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597202",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597202",
  abstract =     "AI models of code have made significant progress over
                 the past few years. However, many models are actually
                 not learning task-relevant source code features.
                 Instead, they often fit non-relevant but correlated
                 data, leading to a lack of robustness and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "145",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Batoun:2023:ESG,
  author =       "Mohamed Amine Batoun and Ka Lai Yung and Yuan Tian and
                 Mohammed Sayagh",
  title =        "An Empirical Study on {GitHub} Pull Requests'
                 Reactions",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "146:1--146:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597208",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597208",
  abstract =     "The pull request mechanism is commonly used to propose
                 source code modifications and get feedback from the
                 community before merging them into a software
                 repository. On GitHub, practitioners can provide
                 feedback on a pull request by either commenting on
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "146",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2023:SEC,
  author =       "Qing Huang and Dianshu Liao and Zhenchang Xing and
                 Zhengkang Zuo and Changjing Wang and Xin Xia",
  title =        "Semantic-Enriched Code Knowledge Graph to Reveal
                 Unknowns in Smart Contract Code Reuse",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "147:1--147:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597206",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597206",
  abstract =     "Programmers who work with smart contract development
                 often encounter challenges in reusing code from
                 repositories. This is due to the presence of two
                 unknowns that can lead to non-functional and functional
                 failures. These unknowns are implicit \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "147",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2023:AIR,
  author =       "Jingxuan Zhang and Junpeng Luo and Jiahui Liang and
                 Lina Gong and Zhiqiu Huang",
  title =        "An Accurate Identifier Renaming Prediction and
                 Suggestion Approach",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "148:1--148:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3603109",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3603109",
  abstract =     "Identifiers play an important role in helping
                 developers analyze and comprehend source code. However,
                 many identifiers exist that are inconsistent with the
                 corresponding code conventions or semantic functions,
                 leading to flawed identifiers. Hence, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "148",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jafari:2023:DUS,
  author =       "Abbas Javan Jafari and Diego Elias Costa and Emad
                 Shihab and Rabe Abdalkareem",
  title =        "Dependency Update Strategies and Package
                 Characteristics",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "149:1--149:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3603110",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3603110",
  abstract =     "Managing project dependencies is a key maintenance
                 issue in software development. Developers need to
                 choose an update strategy that allows them to receive
                 important updates and fixes while protecting them from
                 breaking changes. Semantic Versioning was \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "149",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wei:2023:DMD,
  author =       "Zhengyuan Wei and Haipeng Wang and Imran Ashraf and
                 Wing-Kwong Chan",
  title =        "{DeepPatch}: Maintaining Deep Learning Model Programs
                 to Retain Standard Accuracy with Substantial Robustness
                 Improvement",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "150:1--150:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3604609",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604609",
  abstract =     "Maintaining a deep learning (DL) model by making the
                 model substantially more robust through retraining with
                 plenty of adversarial examples of non-trivial
                 perturbation strength often reduces the model's
                 standard accuracy. Many existing model repair or
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "150",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Do:2023:OTM,
  author =       "Canh Minh Do and Yati Phyo and Adri{\'a}n Riesco and
                 Kazuhiro Ogata",
  title =        "Optimization Techniques for Model Checking Leads-to
                 Properties in a Stratified Way",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "151:1--151:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3604610",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604610",
  abstract =     "We devised the L +1-layer divide \& conquer approach
                 to leads-to model checking ( L +1-DCA2L2MC) and its
                 parallel version, and developed sequential and parallel
                 tools for L +1-DCA2L2MC. In a temporal logic called
                 UNITY, designed by Chandy and Misra, the leads-.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "151",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2023:RIC,
  author =       "Weifeng Sun and Meng Yan and Zhongxin Liu and Xin Xia
                 and Yan Lei and David Lo",
  title =        "Revisiting the Identification of the Co-evolution of
                 Production and Test Code",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "152:1--152:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607183",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607183",
  abstract =     "Many software processes advocate that the test code
                 should co-evolve with the production code. Prior work
                 usually studies such co-evolution based on
                 production-test co-evolution samples mined from
                 software repositories. A production-test co-evolution
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "152",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mo:2023:EIC,
  author =       "Ran Mo and Yao Zhang and Yushuo Wang and Siyuan Zhang
                 and Pu Xiong and Zengyang Li and Yang Zhao",
  title =        "Exploring the Impact of Code Clones on Deep Learning
                 Software",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "153:1--153:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607181",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607181",
  abstract =     "Deep learning (DL) is a really active topic in recent
                 years. Code cloning is a common code implementation
                 that could negatively impact software maintenance. For
                 DL software, developers rely heavily on frameworks to
                 implement DL features. Meanwhile, to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "153",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2023:PPR,
  author =       "Yuheng Huang and Lei Ma and Yuanchun Li",
  title =        "{PatchCensor}: Patch Robustness Certification for
                 Transformers via Exhaustive Testing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "154:1--154:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3591870",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591870",
  abstract =     "In the past few years, Transformer has been widely
                 adopted in many domains and applications because of its
                 impressive performance. Vision Transformer (ViT), a
                 successful and well-known variant, attracts
                 considerable attention from both industry and
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "154",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hutiri:2023:TAF,
  author =       "Wiebke (Toussaint) Hutiri and Aaron Yi Ding and Fahim
                 Kawsar and Akhil Mathur",
  title =        "Tiny, Always-on, and Fragile: Bias Propagation through
                 Design Choices in On-device Machine Learning
                 Workflows",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "155:1--155:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3591867",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591867",
  abstract =     "Billions of distributed, heterogeneous, and resource
                 constrained IoT devices deploy on-device machine
                 learning (ML) for private, fast, and offline inference
                 on personal data. On-device ML is highly context
                 dependent and sensitive to user, usage, hardware,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "155",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2023:RDD,
  author =       "Xuanzhe Liu and Diandian Gu and Zhenpeng Chen and
                 Jinfeng Wen and Zili Zhang and Yun Ma and Haoyu Wang
                 and Xin Jin",
  title =        "Rise of Distributed Deep Learning Training in the Big
                 Model Era: From a Software Engineering Perspective",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "156:1--156:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597204",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597204",
  abstract =     "Deep learning (DL) has become a key component of
                 modern software. In the `` big model '' era, the rich
                 features of DL-based software (i.e., DL software)
                 substantially rely on powerful DL models, e.g., BERT,
                 GPT-3, and the recently emerging GPT-4, which are
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "156",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2023:PIM,
  author =       "Shangwen Wang and Ming Wen and Bo Lin and Yepang Liu
                 and Tegawend{\'e} F. Bissyand{\'e} and Xiaoguang Mao",
  title =        "Pre-implementation Method Name Prediction for
                 Object-oriented Programming",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "157:1--157:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3597203",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3597203",
  abstract =     "Method naming is a challenging development task in
                 object-oriented programming. In recent years, several
                 research efforts have been undertaken to provide
                 automated tool support for assisting developers in this
                 task. In general, literature approaches \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "157",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2023:TPB,
  author =       "Shouguo Yang and Zhengzi Xu and Yang Xiao and Zhe Lang
                 and Wei Tang and Yang Liu and Zhiqiang Shi and Hong Li
                 and Limin Sun",
  title =        "Towards Practical Binary Code Similarity Detection:
                 Vulnerability Verification via Patch Semantic
                 Analysis",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "158:1--158:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3604608",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604608",
  abstract =     "Vulnerability is a major threat to software security.
                 It has been proven that binary code similarity
                 detection approaches are efficient to search for
                 recurring vulnerabilities introduced by code sharing in
                 binary software. However, these approaches suffer
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "158",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rahman:2023:SRA,
  author =       "Mohammad Masudur Rahman and Chanchal K. Roy",
  title =        "A Systematic Review of Automated Query Reformulations
                 in Source Code Search",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "159:1--159:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607179",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607179",
  abstract =     "Fixing software bugs and adding new features are two
                 of the major maintenance tasks. Software bugs and
                 features are reported as change requests. Developers
                 consult these requests and often choose a few keywords
                 from them as an ad hoc query. Then they \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "159",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Qin:2023:NTE,
  author =       "Shisong Qin and Fan Hu and Zheyu Ma and Bodong Zhao
                 and Tingting Yin and Chao Zhang",
  title =        "{NSFuzz}: Towards Efficient and State-Aware Network
                 Service Fuzzing",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "160:1--160:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580598",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580598",
  abstract =     "As an essential component responsible for
                 communication, network services are security critical,
                 thus, it is vital to find their vulnerabilities.
                 Fuzzing is currently one of the most popular software
                 vulnerability discovery techniques, widely adopted due
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "160",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2023:NTE,
  author =       "Fan Hu and Shisong Qin and Zheyu Ma and Bodong Zhao
                 and Tingting Yin and Chao Zhang",
  title =        "{NSFuzz}: Towards Efficient and State-Aware Network
                 Service Fuzzing --- {RCR} Report",
  journal =      j-TOSEM,
  volume =       "32",
  number =       "6",
  pages =        "161:1--161:??",
  month =        nov,
  year =         "2023",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3580599",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Oct 4 09:43:36 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3580599",
  abstract =     "We provide artifacts to reproduce the evaluation
                 results of our article: ``NSFuzz: Towards Efficient and
                 State-Aware Network Service Fuzzing''. The provided
                 artifacts can be downloaded from . It includes 14
                 docker containers,  \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "161",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2024:ETF,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial: Toward the Future with Eight Issues Per
                 Year",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637444",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637444",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1e",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2024:APE,
  author =       "Shouguo Yang and Chaopeng Dong and Yang Xiao and Yiran
                 Cheng and Zhiqiang Shi and Zhi Li and Limin Sun",
  title =        "{Asteria-Pro}: Enhancing Deep Learning-based Binary
                 Code Similarity Detection by Incorporating Domain
                 Knowledge",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3604611",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604611",
  abstract =     "Widespread code reuse allows vulnerabilities to
                 proliferate among a vast variety of firmware. There is
                 an urgent need to detect these vulnerable codes
                 effectively and efficiently. By measuring code
                 similarities, AI-based binary code similarity
                 detection. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:APE,
  author =       "Xuanzhe Liu and Chengxu Yang and Ding Li and Yuhan
                 Zhou and Shaofei Li and Jiali Chen and Zhenpeng Chen",
  title =        "{Adonis}: Practical and Efficient Control Flow
                 Recovery through {OS}-level Traces",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607187",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607187",
  abstract =     "Control flow recovery is critical to promise the
                 software quality, especially for large-scale software
                 in production environment. However, the efficiency of
                 most current control flow recovery techniques is
                 compromised due to their runtime overheads along
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ma:2024:FLD,
  author =       "Suyu Ma and Chunyang Chen and Hourieh Khalajzadeh and
                 John Grundy",
  title =        "A First Look at Dark Mode in Real-world {Android}
                 Apps",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3604607",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604607",
  abstract =     "Android apps often have a ``dark mode'' option used in
                 low-light situations, for those who find the
                 conventional color palette problematic, or because of
                 personal preferences. Typically developers add a dark
                 mode option for their apps with different \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2024:PEM,
  author =       "Jiarong Wu and Lili Wei and Yanyan Jiang and Shing-Chi
                 Cheung and Luyao Ren and Chang Xu",
  title =        "Programming by Example Made Easy",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607185",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607185",
  abstract =     "Programming by example (PBE) is an emerging
                 programming paradigm that automatically synthesizes
                 programs specified by user-provided input-output
                 examples. Despite the convenience for end-users,
                 implementing PBE tools often requires strong expertise
                 in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bessghaier:2024:WCD,
  author =       "Narjes Bessghaier and Mohammed Sayagh and Ali Ouni and
                 Mohamed Wiem Mkaouer",
  title =        "What Constitutes the Deployment and Runtime
                 Configuration System? {An} Empirical Study on
                 {OpenStack} Projects",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "5:1--5:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607186",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607186",
  abstract =     "Modern software systems are designed to be deployed in
                 different configured environments (e.g., permissions,
                 virtual resources, network connections) and adapted at
                 runtime to different situations (e.g., memory limits,
                 enabling/disabling features, database \ldots{})",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:AER,
  author =       "Qing Huang and Yanbang Sun and Zhenchang Xing and Min
                 Yu and Xiwei Xu and Qinghua Lu",
  title =        "{API} Entity and Relation Joint Extraction from Text
                 via Dynamic Prompt-tuned Language Model",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "6:1--6:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607188",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607188",
  abstract =     "Extraction of Application Programming Interfaces
                 (APIs) and their semantic relations from unstructured
                 text (e.g., Stack Overflow) is a fundamental work for
                 software engineering tasks (e.g., API recommendation).
                 However, existing approaches are rule based \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Oh:2024:FNO,
  author =       "Jeho Oh and Don Batory and Rub{\'e}n Heradio",
  title =        "Finding Near-optimal Configurations in Colossal Spaces
                 with Statistical Guarantees",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "7:1--7:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611663",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611663",
  abstract =     "A Software Product Line (SPL) is a family of similar
                 programs. Each program is defined by a unique set of
                 features, called a configuration, that satisfies all
                 feature constraints. ``What configuration achieves the
                 best performance for a given workload?'' is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2024:IGM,
  author =       "Chang-Ai Sun and Hepeng Dai and Ning Geng and Huai Liu
                 and Tsong Yueh Chen and Peng Wu and Yan Cai and Jinqiu
                 Wang",
  title =        "An Interleaving Guided Metamorphic Testing Approach
                 for Concurrent Programs",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "8:1--8:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607182",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607182",
  abstract =     "Concurrent programs are normally composed of multiple
                 concurrent threads sharing memory space. These threads
                 are often interleaved, which may lead to some
                 non-determinism in execution results, even for the same
                 program input. This poses huge challenges to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Taipalus:2024:FSE,
  author =       "Toni Taipalus and Hilkka Grahn",
  title =        "Framework for {SQL} Error Message Design: a
                 Data-Driven Approach",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "9:1--9:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607180",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607180",
  abstract =     "Software developers use a significant amount of time
                 reading and interpreting error messages. However, error
                 messages have often been based on either anecdotal
                 evidence or expert opinion, disregarding novices, who
                 arguably are the ones who benefit the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Clark:2024:TCS,
  author =       "Andrew G. Clark and Michael Foster and Benedikt
                 Prifling and Neil Walkinshaw and Robert M. Hierons and
                 Volker Schmidt and Robert D. Turner",
  title =        "Testing Causality in Scientific Modelling Software",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "10:1--10:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607184",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607184",
  abstract =     "From simulating galaxy formation to viral transmission
                 in a pandemic, scientific models play a pivotal role in
                 developing scientific theories and supporting
                 government policy decisions that affect us all. Given
                 these critical applications, a poor \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:HAK,
  author =       "Jianzhong Liu and Yuheng Shen and Yiru Xu and Hao Sun
                 and Yu Jiang",
  title =        "{Horus}: Accelerating Kernel Fuzzing through Efficient
                 {Host--VM} Memory Access Procedures",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "11:1--11:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611665",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611665",
  abstract =     "Kernel fuzzing is an effective technique in operating
                 system vulnerability detection. Fuzzers such as
                 Syzkaller and Moonshine frequently pass highly
                 structured data between fuzzer processes in guest
                 virtual machines and manager processes in the host
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Entekhabi:2024:AET,
  author =       "Sina Entekhabi and Wojciech Mostowski and Mohammad
                 Reza Mousavi",
  title =        "Automated and Efficient Test-Generation for Grid-Based
                 Multiagent Systems: Comparing Random Input Filtering
                 versus Constraint Solving",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "12:1--12:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624736",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624736",
  abstract =     "Automatic generation of random test inputs is an
                 approach that can alleviate the challenges of manual
                 test case design. However, random test cases may be
                 ineffective in fault detection and increase testing
                 cost, especially in systems where test execution
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Furia:2024:TCA,
  author =       "Carlo A. Furia and Richard Torkar and Robert Feldt",
  title =        "Towards Causal Analysis of Empirical Software
                 Engineering Data: The Impact of Programming Languages
                 on Coding Competitions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "13:1--13:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611667",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611667",
  abstract =     "There is abundant observational data in the software
                 engineering domain, whereas running large-scale
                 controlled experiments is often practically impossible.
                 Thus, most empirical studies can only report
                 statistical correlations -instead of potentially more
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nourry:2024:HSF,
  author =       "Olivier Nourry and Yutaro Kashiwa and Bin Lin and
                 Gabriele Bavota and Michele Lanza and Yasutaka Kamei",
  title =        "The Human Side of Fuzzing: Challenges Faced by
                 Developers during Fuzzing Activities",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "14:1--14:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611668",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611668",
  abstract =     "Fuzz testing, also known as fuzzing, is a software
                 testing technique aimed at identifying software
                 vulnerabilities. In recent decades, fuzzing has gained
                 increasing popularity in the research community.
                 However, existing studies led by fuzzing experts
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:ADI,
  author =       "Pei Liu and Yanjie Zhao and Mattia Fazzini and Haipeng
                 Cai and John Grundy and Li Li",
  title =        "Automatically Detecting Incompatible {Android}
                 {APIs}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "15:1--15:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624737",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624737",
  abstract =     "Fragmentation is a serious problem in the Android
                 ecosystem, which is mainly caused by the fast evolution
                 of the system itself and the various system
                 customizations. Many efforts have attempted to mitigate
                 its impact via approaches to automatically \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhu:2024:SAG,
  author =       "Hengcheng Zhu and Lili Wei and Valerio Terragni and
                 Yepang Liu and Shing-Chi Cheung and Jiarong Wu and Qin
                 Sheng and Bing Zhang and Lihong Song",
  title =        "{StubCoder}: Automated Generation and Repair of Stub
                 Code for {Mock} Objects",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "16:1--16:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617171",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617171",
  abstract =     "Mocking is an essential unit testing technique for
                 isolating the class under test from its dependencies.
                 Developers often leverage mocking frameworks to develop
                 stub code that specifies the behaviors of mock objects.
                 However, developing and maintaining \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tian:2024:CSS,
  author =       "Yongqiang Tian and Xueyan Zhang and Yiwen Dong and
                 Zhenyang Xu and Mengxiao Zhang and Yu Jiang and
                 Shing-Chi Cheung and Chengnian Sun",
  title =        "On the Caching Schemes to Speed Up Program Reduction",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "17:1--17:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617172",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617172",
  abstract =     "Program reduction is a highly practical, widely
                 demanded technique to help debug language tools, such
                 as compilers, interpreters and debuggers. Given a
                 program P that exhibits a property $ \psi $,
                 conceptually, program reduction iteratively applies
                 various \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mandrioli:2024:TAC,
  author =       "Claudio Mandrioli and Max Nyberg Carlsson and Martina
                 Maggio",
  title =        "Testing Abstractions for Cyber-Physical Control
                 Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "18:1--18:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617170",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617170",
  abstract =     "Control systems are ubiquitous and often at the core
                 of Cyber-Physical Systems, like cars and aeroplanes.
                 They are implemented as embedded software that
                 interacts in closed loop with the physical world
                 through sensors and actuators. As a consequence, the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fang:2024:DQP,
  author =       "Wang Fang and Mingsheng Ying and Xiaodi Wu",
  title =        "Differentiable Quantum Programming with Unbounded
                 Loops",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "19:1--19:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617178",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617178",
  abstract =     "The emergence of variational quantum applications has
                 led to the development of automatic differentiation
                 techniques in quantum computing. Existing work has
                 formulated differentiable quantum programming with
                 bounded loops, providing a framework for \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2024:TTI,
  author =       "Yuanhang Yang and Wei He and Cuiyun Gao and Zenglin Xu
                 and Xin Xia and Chuanyi Liu",
  title =        "{TopicAns}: Topic-informed Architecture for Answer
                 Recommendation on Technical {Q\&A} Site",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "20:1--20:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607189",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607189",
  abstract =     "Technical Q\&A sites, such as Stack Overflow and Ask
                 Ubuntu, have been widely utilized by software engineers
                 to seek support for development challenges. However,
                 not all the raised questions get instant feedback, and
                 the retrieved answers can vary in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:FRF,
  author =       "Tianlin Li and Xiaofei Xie and Jian Wang and Qing Guo
                 and Aishan Liu and Lei Ma and Yang Liu",
  title =        "{Faire}: Repairing Fairness of Neural Networks via
                 Neuron Condition Synthesis",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "21:1--21:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617168",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617168",
  abstract =     "Deep Neural Networks (DNNs) have achieved tremendous
                 success in many applications, while it has been
                 demonstrated that DNNs can exhibit some undesirable
                 behaviors on concerns such as robustness, privacy, and
                 other trustworthiness issues. Among them, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dang:2024:GMB,
  author =       "Xueqi Dang and Yinghua Li and Mike Papadakis and
                 Jacques Klein and Tegawend{\'e} F. Bissyand{\'e} and
                 Yves {Le Traon}",
  title =        "{GraphPrior}: Mutation-based Test Input Prioritization
                 for Graph Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "22:1--22:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607191",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607191",
  abstract =     "Graph Neural Networks (GNNs) have achieved promising
                 performance in a variety of practical applications.
                 Similar to traditional DNNs, GNNs could exhibit
                 incorrect behavior that may lead to severe
                 consequences, and thus testing is necessary and
                 crucial. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhi:2024:SST,
  author =       "Yuhan Zhi and Xiaofei Xie and Chao Shen and Jun Sun
                 and Xiaoyu Zhang and Xiaohong Guan",
  title =        "Seed Selection for Testing Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "23:1--23:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3607190",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3607190",
  abstract =     "Deep learning (DL) has been applied in many
                 applications. Meanwhile, the quality of DL systems is
                 becoming a big concern. To evaluate the quality of DL
                 systems, a number of DL testing techniques have been
                 proposed. To generate test cases, a set of initial
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2024:SCG,
  author =       "Hanyang Guo and Xiangping Chen and Yuan Huang and
                 Yanlin Wang and Xi Ding and Zibin Zheng and Xiaocong
                 Zhou and Hong-Ning Dai",
  title =        "Snippet Comment Generation Based on Code Context
                 Expansion",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "24:1--24:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611664",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611664",
  abstract =     "Code commenting plays an important role in program
                 comprehension. Automatic comment generation helps
                 improve software maintenance efficiency. The code
                 comments to annotate a method mainly include header
                 comments and snippet comments. The header comment
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2024:LLF,
  author =       "Qiang Hu and Yuejun Guo and Xiaofei Xie and Maxime
                 Cordy and Mike Papadakis and Yves {Le Traon}",
  title =        "{LaF}: Labeling-free Model Selection for Automated
                 Deep Neural Network Reusing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "25:1--25:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3611666",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3611666",
  abstract =     "Applying deep learning (DL) to science is a new trend
                 in recent years, which leads DL engineering to become
                 an important problem. Although training data
                 preparation, model architecture design, and model
                 training are the normal processes to build DL models,.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2024:FLD,
  author =       "Han Hu and Yujin Huang and Qiuyuan Chen and Terry Yue
                 Zhuo and Chunyang Chen",
  title =        "A First Look at On-device Models in {iOS} Apps",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "26:1--26:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617177",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617177",
  abstract =     "Powered by the rising popularity of deep learning
                 techniques on smartphones, on-device deep learning
                 models are being used in vital fields such as finance,
                 social media, and driving assistance. Because of the
                 transparency of the Android platform and the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Golmohammadi:2024:TRA,
  author =       "Amid Golmohammadi and Man Zhang and Andrea Arcuri",
  title =        "Testing {RESTful APIs}: a Survey",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "27:1--27:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617175",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617175",
  abstract =     "In industry, RESTful APIs are widely used to build
                 modern Cloud Applications. Testing them is challenging,
                 because not only do they rely on network
                 communications, but also they deal with external
                 services like databases. Therefore, there has been a
                 large \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Weiss:2024:ATSa,
  author =       "Michael Weiss and Paolo Tonella",
  title =        "Adopting Two Supervisors for Efficient Use of
                 Large-Scale Remote Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "28:1--28:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617593",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617593",
  abstract =     "Recent decades have seen the rise of large-scale Deep
                 Neural Networks (DNNs) to achieve human-competitive
                 performance in a variety of AI tasks. Often consisting
                 of hundreds of million, if not hundreds of billion,
                 parameters, these DNNs are too large to be \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Weiss:2024:ATSb,
  author =       "Michael Weiss and Paolo Tonella",
  title =        "Adopting Two Supervisors for Efficient Use of
                 Large-Scale Remote Deep Neural Networks --- {RCR}
                 Report",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "1",
  pages =        "29:1--29:??",
  month =        jan,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617594",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:06 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617594",
  abstract =     "This is the Replicated Computational Results (RCR)
                 Report for our TOSEM paper ``Adopting Two Supervisors
                 for Efficient Use of Large-Scale Remote Deep Neural
                 Networks'', where we propose a novel client-server
                 architecture allowing to leverage the high \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2024:DDR,
  author =       "Yu Zhou and Weilin Zhan and Zi Li and Tingting Han and
                 Taolue Chen and Harald Gall",
  title =        "{DRIVE}: Dockerfile Rule Mining and Violation
                 Detection",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "30:1--30:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617173",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617173",
  abstract =     "A Dockerfile defines a set of instructions to build
                 Docker images, which can then be instantiated to
                 support containerized applications. Recent studies have
                 revealed a considerable amount of quality issues with
                 Dockerfiles. In this article, we propose a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:FIP,
  author =       "Qing Huang and Zhiqiang Yuan and Zhenchang Xing and
                 Xin Peng and Xiwei Xu and Qinghua Lu",
  title =        "{FQN} Inference in Partial Code by Prompt-tuned
                 Language Model of Code",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "31:1--31:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617174",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617174",
  abstract =     "Partial code usually involves non-fully-qualified type
                 names (non-FQNs) and undeclared receiving objects.
                 Resolving the FQNs of these non-FQN types and
                 undeclared receiving objects (referred to as type
                 inference) is the prerequisite to effective search
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lee:2024:PSW,
  author =       "Jaekwon Lee and Seung Yeob Shin and Lionel C. Briand
                 and Shiva Nejati",
  title =        "Probabilistic Safe {WCET} Estimation for Weakly Hard
                 Real-time Systems at Design Stages",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "32:1--32:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617176",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617176",
  abstract =     "Weakly hard real-time systems can, to some degree,
                 tolerate deadline misses, but their schedulability
                 still needs to be analyzed to ensure their quality of
                 service. Such analysis usually occurs at early design
                 stages to provide implementation guidelines \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Rolland:2024:ASN,
  author =       "Knut H. Rolland and Brian Fitzgerald and Torgeir
                 Dings{\o}yr and Klaas-Jan Stol",
  title =        "Acrobats and Safety Nets: Problematizing Large-Scale
                 Agile Software Development",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "33:1--33:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3617169",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3617169",
  abstract =     "Agile development methods have become a standard in
                 the software industry, including in large-scale
                 projects. These methods share a set of underlying
                 assumptions that distinguish them from more traditional
                 plan-driven approaches. In this article, we adopt
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zheng:2024:CLS,
  author =       "Xiaoye Zheng and Zhiyuan Wan and Yun Zhang and Rui
                 Chang and David Lo",
  title =        "A Closer Look at the Security Risks in the {Rust}
                 Ecosystem",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "34:1--34:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624738",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624738",
  abstract =     "Rust is an emerging programming language designed for
                 the development of systems software. To facilitate the
                 reuse of Rust code, crates.io, as a central package
                 registry of the Rust ecosystem, hosts thousands of
                 third-party Rust packages. The openness of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mandrioli:2024:STC,
  author =       "Claudio Mandrioli and Seung Yeob Shin and Martina
                 Maggio and Domenico Bianculli and Lionel Briand",
  title =        "Stress Testing Control Loops in Cyber-physical
                 Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "35:1--35:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624742",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624742",
  abstract =     "Cyber-physical Systems (CPSs) are often
                 safety-critical and deployed in uncertain environments.
                 Identifying scenarios where CPSs do not comply with
                 requirements is fundamental but difficult due to the
                 multidisciplinary nature of CPSs. We investigate the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Khatoonabadi:2024:UHS,
  author =       "Sayedhassan Khatoonabadi and Diego Elias Costa and
                 Suhaib Mujahid and Emad Shihab",
  title =        "Understanding the Helpfulness of Stale Bot for
                 Pull-Based Development: an Empirical Study of 20 Large
                 Open-Source Projects",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "36:1--36:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624739",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624739",
  abstract =     "Pull Requests (PRs) that are neither progressed nor
                 resolved clutter the list of PRs, making it difficult
                 for the maintainers to manage and prioritize unresolved
                 PRs. To automatically track, follow up, and close such
                 inactive PRs, Stale bot was introduced \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2024:CDW,
  author =       "Yixuan Zhang and Shangtong Cao and Haoyu Wang and
                 Zhenpeng Chen and Xiapu Luo and Dongliang Mu and Yun Ma
                 and Gang Huang and Xuanzhe Liu",
  title =        "Characterizing and Detecting {WebAssembly} Runtime
                 Bugs",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "37:1--37:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624743",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624743",
  abstract =     "WebAssembly (abbreviated WASM) has emerged as a
                 promising language of the Web and also been used for a
                 wide spectrum of software applications such as mobile
                 applications and desktop applications. These
                 applications, named WASM applications, commonly run
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ding:2024:LPI,
  author =       "Zishuo Ding and Yiming Tang and Xiaoyu Cheng and Heng
                 Li and Weiyi Shang",
  title =        "{LoGenText-Plus}: Improving Neural Machine Translation
                 Based Logging Texts Generation with Syntactic
                 Templates",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "38:1--38:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624740",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624740",
  abstract =     "Developers insert logging statements in the source
                 code to collect important runtime information about
                 software systems. The textual descriptions in logging
                 statements (i.e., logging texts) are printed during
                 system executions and exposed to multiple \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shi:2024:ASE,
  author =       "Weishi Shi and Heather Moses and Qi Yu and Samuel
                 Malachowsky and Daniel E. Krutz",
  title =        "{ALL}: Supporting Experiential Accessibility Education
                 and Inclusive Software Development",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "39:1--39:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3625292",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3625292",
  abstract =     "Creating accessible software is imperative for making
                 software inclusive for all users.Unfortunately, the
                 topic of accessibility is frequently excluded from
                 computing education, leading to scenarios where
                 students are unaware of either how to develop
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "39",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Formica:2024:SBS,
  author =       "Federico Formica and Tony Fan and Claudio Menghi",
  title =        "Search-Based Software Testing Driven by Automatically
                 Generated and Manually Defined Fitness Functions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "40:1--40:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624745",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624745",
  abstract =     "Search-based software testing (SBST) typically relies
                 on fitness functions to guide the search exploration
                 toward software failures. There are two main techniques
                 to define fitness functions: (a) automated fitness
                 function computation from the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "40",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2024:VBF,
  author =       "Jiajun Jiang and Yumeng Wang and Junjie Chen and Delin
                 Lv and Mengjiao Liu",
  title =        "Variable-based Fault Localization via Enhanced
                 Decision Tree",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "41:1--41:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624741",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624741",
  abstract =     "Fault localization, aiming at localizing the root
                 cause of the bug under repair, has been a longstanding
                 research topic. Although many approaches have been
                 proposed in past decades, most of the existing studies
                 work at coarse-grained statement or method \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "41",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:HDA,
  author =       "Wei Huang and Xingyu Zhao and Alec Banks and Victoria
                 Cox and Xiaowei Huang",
  title =        "Hierarchical Distribution-aware Testing of Deep
                 Learning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "42:1--42:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3625290",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3625290",
  abstract =     "With its growing use in safety/security-critical
                 applications, Deep Learning (DL) has raised increasing
                 concerns regarding its dependability. In particular, DL
                 has a notorious problem of lacking robustness. Input
                 added with adversarial perturbations, i.e.,. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "42",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cao:2024:LDM,
  author =       "Sicong Cao and Xiaobing Sun and Lili Bo and Rongxin Wu
                 and Bin Li and Xiaoxue Wu and Chuanqi Tao and Tao Zhang
                 and Wei Liu",
  title =        "Learning to Detect Memory-related Vulnerabilities",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "43:1--43:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624744",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624744",
  abstract =     "Memory-related vulnerabilities can result in
                 performance degradation or even program crashes,
                 constituting severe threats to the security of modern
                 software. Despite the promising results of deep
                 learning (DL)-based vulnerability detectors, there
                 exist \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "43",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ismayilzada:2024:PTP,
  author =       "Elkhan Ismayilzada and Md Mazba Ur Rahman and Dongsun
                 Kim and Jooyong Yi",
  title =        "{Poracle}: Testing Patches under Preservation
                 Conditions to Combat the Overfitting Problem of Program
                 Repair",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "44:1--44:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3625293",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3625293",
  abstract =     "To date, the users of test-driven program repair tools
                 suffer from the overfitting problem; a generated patch
                 may pass all available tests without being correct. In
                 the existing work, users are treated as merely passive
                 consumers of the tests. However, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "44",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2024:CVD,
  author =       "Yuanhang Zhou and Fuchen Ma and Yuanliang Chen and
                 Meng Ren and Yu Jiang",
  title =        "{CLFuzz}: Vulnerability Detection of Cryptographic
                 Algorithm Implementation via Semantic-aware Fuzzing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "45:1--45:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3628160",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3628160",
  abstract =     "Cryptography is a core component of many security
                 applications, and flaws hidden in its implementation
                 will affect the functional integrity or, more severely,
                 pose threats to data security. Hence, guaranteeing the
                 correctness of the implementation is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "45",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xiang:2024:ATS,
  author =       "Yi Xiang and Han Huang and Sizhe Li and Miqing Li and
                 Chuan Luo and Xiaowei Yang",
  title =        "Automated Test Suite Generation for Software Product
                 Lines Based on Quality-Diversity Optimization",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "46:1--46:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3628158",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3628158",
  abstract =     "A Software Product Line (SPL) is a set of software
                 products that are built from a variability model.
                 Real-world SPLs typically involve a vast number of
                 valid products, making it impossible to individually
                 test each of them. This arises the need for \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "46",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2024:AMA,
  author =       "Han Hu and Ruiqi Dong and John Grundy and Thai Minh
                 Nguyen and Huaxiao Liu and Chunyang Chen",
  title =        "Automated Mapping of Adaptive App {GUIs} from Phones
                 to {TVs}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "47:1--47:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631968",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631968",
  abstract =     "With the increasing interconnection of smart devices,
                 users often desire to adopt the same app on quite
                 different devices for identical tasks, such as watching
                 the same movies on both their smartphones and TVs.
                 However, the significant differences in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "47",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2024:KKN,
  author =       "Yuejun Guo and Qiang Hu and Xiaofei Xie and Maxime
                 Cordy and Mike Papadakis and {Yves Le Traon}",
  title =        "{KAPE}: $k$ {NN}-based Performance Testing for Deep
                 Code Search",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "48:1--48:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624735",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624735",
  abstract =     "Code search is a common yet important activity of
                 software developers. An efficient code search model can
                 largely facilitate the development process and improve
                 the programming quality. Given the superb performance
                 of learning the contextual \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "48",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2024:ALI,
  author =       "Jiamou Sun and Zhenchang Xing and Xin Xia and Qinghua
                 Lu and Xiwei Xu and Liming Zhu",
  title =        "Aspect-level Information Discrepancies across
                 Heterogeneous Vulnerability Reports: Severity, Types
                 and Detection Methods",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "49:1--49:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3624734",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3624734",
  abstract =     "Vulnerable third-party libraries pose significant
                 threats to software applications that reuse these
                 libraries. At an industry scale of reuse, manual
                 analysis of third-party library vulnerabilities can be
                 easily overwhelmed by the sheer number of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "49",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:GBD,
  author =       "Jiawei Liu and Yuheng Huang and Zhijie Wang and Lei Ma
                 and Chunrong Fang and Mingzheng Gu and Xufan Zhang and
                 Zhenyu Chen",
  title =        "Generation-based Differential Fuzzing for Deep
                 Learning Libraries",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "50:1--50:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3628159",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3628159",
  abstract =     "Deep learning (DL) libraries have become the key
                 component in developing and deploying DL-based software
                 nowadays. With the growing popularity of applying DL
                 models in both academia and industry across various
                 domains, any bugs inherent in the DL \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "50",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shin:2024:GBM,
  author =       "Jiho Shin and Moshi Wei and Junjie Wang and Lin Shi
                 and Song Wang",
  title =        "The Good, the Bad, and the Missing: Neural Code
                 Generation for Machine Learning Tasks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "51:1--51:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3630009",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3630009",
  abstract =     "Machine learning (ML) has been increasingly used in a
                 variety of domains, while solving ML programming tasks
                 poses unique challenges due to the fundamental
                 difference in the nature and the construct of general
                 programming tasks, especially for developers \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "51",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:LAM,
  author =       "Siyuan Li and Yongpan Wang and Chaopeng Dong and
                 Shouguo Yang and Hong Li and Hao Sun and Zhe Lang and
                 Zuxin Chen and Weijie Wang and Hongsong Zhu and Limin
                 Sun",
  title =        "{LibAM}: an Area Matching Framework for Detecting
                 Third-Party Libraries in Binaries",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "52:1--52:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3625294",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3625294",
  abstract =     "Third-party libraries (TPLs) are extensively utilized
                 by developers to expedite the software development
                 process and incorporate external functionalities.
                 Nevertheless, insecure TPL reuse can lead to
                 significant security risks. Existing methods, which
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "52",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dutra:2024:FEF,
  author =       "Rafael Dutra and Rahul Gopinath and Andreas Zeller",
  title =        "{FormatFuzzer}: Effective Fuzzing of Binary File
                 Formats",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "53:1--53:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3628157",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3628157",
  abstract =     "Effective fuzzing of programs that process structured
                 binary inputs, such as multimedia files, is a
                 challenging task, since those programs expect a very
                 specific input format. Existing fuzzers, however, are
                 mostly format-agnostic, which makes them \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "53",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xie:2024:SCS,
  author =       "Yutao Xie and Jiayi Lin and Hande Dong and Lei Zhang
                 and Zhonghai Wu",
  title =        "Survey of Code Search Based on Deep Learning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "54:1--54:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3628161",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3628161",
  abstract =     "Code writing is repetitive and predictable, inspiring
                 us to develop various code intelligence techniques.
                 This survey focuses on code search, that is, to
                 retrieve code that matches a given natural language
                 query by effectively capturing the semantic \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "54",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2024:SLB,
  author =       "Quanjun Zhang and Chunrong Fang and Yuxiang Ma and
                 Weisong Sun and Zhenyu Chen",
  title =        "A Survey of Learning-based Automated Program Repair",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "2",
  pages =        "55:1--55:??",
  month =        feb,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631974",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:08 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631974",
  abstract =     "Automated program repair (APR) aims to fix software
                 bugs automatically and plays a crucial role in software
                 development and maintenance. With the recent advances
                 in deep learning (DL), an increasing number of APR
                 techniques have been proposed to leverage \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "55",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xiao:2024:MEC,
  author =       "Ya Xiao and Wenjia Song and Salman Ahmed and Xinyang
                 Ge and Bimal Viswanath and Na Meng and Danfeng (Daphne)
                 Yao",
  title =        "Measurement of Embedding Choices on Cryptographic
                 {API} Completion Tasks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "56:1--56:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3625291",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3625291",
  abstract =     "In this article, we conduct a measurement study to
                 comprehensively compare the accuracy impacts of
                 multiple embedding options in cryptographic API
                 completion tasks. Embedding is the process of
                 automatically learning vector representations of
                 program \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "56",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Russo:2024:UDWa,
  author =       "Daniel Russo and Paul H. P. Hanel and Niels {Van
                 Berkel}",
  title =        "Understanding Developers Well-Being and Productivity:
                 a 2-year Longitudinal Analysis during the {COVID-19}
                 Pandemic",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "57:1--57:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3638244",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3638244",
  abstract =     "The COVID-19 pandemic has brought significant and
                 enduring shifts in various aspects of life, including
                 increased flexibility in work arrangements. In a
                 longitudinal study, spanning 24 months with six
                 measurement points from April 2020 to April 2022, we
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "57",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lustosa:2024:LVL,
  author =       "Andre Lustosa and Tim Menzies",
  title =        "Learning from Very Little Data: On the Value of
                 Landscape Analysis for Predicting Software Project
                 Health",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "58:1--58:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3630252",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3630252",
  abstract =     "When data is scarce, software analytics can make many
                 mistakes. For example, consider learning predictors for
                 open source project health (e.g., the number of closed
                 pull requests in 12 months time). The training data for
                 this task may be very small (e.g., \ldots{})",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "58",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2024:LWC,
  author =       "Yanming Yang and Xing Hu and Xin Xia and Xiaohu Yang",
  title =        "The Lost World: Characterizing and Detecting
                 Undiscovered Test Smells",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "59:1--59:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631973",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631973",
  abstract =     "Test smell refers to poor programming and design
                 practices in testing and widely spreads throughout
                 software projects. Considering test smells have
                 negative impacts on the comprehension and maintenance
                 of test code and even make code-under-test more
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "59",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2024:HIG,
  author =       "Guang Yang and Yu Zhou and Wenhua Yang and Tao Yue and
                 Xiang Chen and Taolue Chen",
  title =        "How Important Are Good Method Names in Neural Code
                 Generation? {A} Model Robustness Perspective",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "60:1--60:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3630010",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3630010",
  abstract =     "Pre-trained code generation models (PCGMs) have been
                 widely applied in neural code generation, which can
                 generate executable code from functional descriptions
                 in natural languages, possibly together with
                 signatures. Despite substantial performance \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "60",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2024:PTF,
  author =       "Jiajun Jiang and Junjie Yang and Yingyi Zhang and Zan
                 Wang and Hanmo You and Junjie Chen",
  title =        "A Post-training Framework for Improving the
                 Performance of Deep Learning Models via Model
                 Transformation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "61:1--61:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3630011",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3630011",
  abstract =     "Deep learning (DL) techniques have attracted much
                 attention in recent years and have been applied to many
                 application scenarios. To improve the performance of DL
                 models regarding different properties, many approaches
                 have been proposed in the past decades,. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "61",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{xexx:2024:PAP,
  author =       "Jia Li and Zhuo Li and Huangzhao Zhang and Ge Li and
                 Zhi Jin and Xing Hu and Xin Xia",
  title =        "Poison Attack and Poison Detection on Deep Source Code
                 Processing Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "62:1--62:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3630008",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3630008",
  abstract =     "In the software engineering (SE) community, deep
                 learning (DL) has recently been applied to many source
                 code processing tasks, achieving state-of-the-art
                 results. Due to the poor interpretability of DL models,
                 their security vulnerabilities require \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "62",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:HMS,
  author =       "Wen Li and Austin Marino and Haoran Yang and Na Meng
                 and Li Li and Haipeng Cai",
  title =        "How Are Multilingual Systems Constructed:
                 Characterizing Language Use and Selection in
                 Open-Source Multilingual Software",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "63:1--63:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631967",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631967",
  abstract =     "For many years now, modern software is known to be
                 developed in multiple languages (hence termed as
                 multilingual or multi-language software). Yet, to date,
                 we still only have very limited knowledge about how
                 multilingual software systems are constructed.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "63",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kochanthara:2024:SPS,
  author =       "Sangeeth Kochanthara and Tajinder Singh and Alexandru
                 Forrai and Loek Cleophas",
  title =        "Safety of Perception Systems for Automated Driving: a
                 Case Study on {Apollo}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "64:1--64:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631969",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631969",
  abstract =     "The automotive industry is now known for its
                 software-intensive and safety-critical nature. The
                 industry is on a path to the holy grail of completely
                 automating driving, starting from relatively simple
                 operational areas like highways. One of the most
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "64",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zirak:2024:IAP,
  author =       "Armin Zirak and Hadi Hemmati",
  title =        "Improving Automated Program Repair with Domain
                 Adaptation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "65:1--65:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631972",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631972",
  abstract =     "Automated Program Repair (APR) is defined as the
                 process of fixing a bug/defect in the source code, by
                 an automated tool. APR tools have recently experienced
                 promising results by leveraging state-of-the-art Neural
                 Language Processing (NLP) techniques. APR \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "65",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tang:2024:OSV,
  author =       "Wensheng Tang and Dejun Dong and Shijie Li and
                 Chengpeng Wang and Peisen Yao and Jinguo Zhou and
                 Charles Zhang",
  title =        "{Octopus}: Scaling Value-Flow Analysis via Parallel
                 Collection of Realizable Path Conditions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "66:1--66:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3632743",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3632743",
  abstract =     "Value-flow analysis is a fundamental technique in
                 program analysis, benefiting various clients, such as
                 memory corruption detection and taint analysis.
                 However, existing efforts suffer from the low potential
                 speedup that leads to a deficiency in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "66",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhu:2024:DBE,
  author =       "Tingwei Zhu and Zhong Li and Minxue Pan and Chaoxuan
                 Shi and Tian Zhang and Yu Pei and Xuandong Li",
  title =        "Deep Is Better? {An} Empirical Comparison of
                 Information Retrieval and Deep Learning Approaches to
                 Code Summarization",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "67:1--67:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631975",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631975",
  abstract =     "Code summarization aims to generate short functional
                 descriptions for source code to facilitate code
                 comprehension. While Information Retrieval (IR)
                 approaches that leverage similar code snippets and
                 corresponding summaries have led the early research,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "67",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2024:ADU,
  author =       "Zhe Zhao and Guangke Chen and Tong Liu and Taishan Li
                 and Fu Song and Jingyi Wang and Jun Sun",
  title =        "Attack as Detection: Using Adversarial Attack Methods
                 to Detect Abnormal Examples",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "68:1--68:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631977",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631977",
  abstract =     "As a new programming paradigm, deep learning (DL) has
                 achieved impressive performance in areas such as image
                 processing and speech recognition, and has expanded its
                 application to solve many real-world problems. However,
                 neural networks and DL are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "68",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{He:2024:RLS,
  author =       "Junda He and Xin Zhou and Bowen Xu and Ting Zhang and
                 Kisub Kim and Zhou Yang and Ferdian Thung and Ivana
                 Clairine Irsan and David Lo",
  title =        "Representation Learning for {Stack Overflow} Posts:
                 How Far Are We?",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "69:1--69:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635711",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635711",
  abstract =     "The tremendous success of Stack Overflow has
                 accumulated an extensive corpus of software engineering
                 knowledge, thus motivating researchers to propose
                 various solutions for analyzing its content. The
                 performance of such solutions hinges significantly on
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "69",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Qi:2024:RCN,
  author =       "Binhang Qi and Hailong Sun and Hongyu Zhang and Xiang
                 Gao",
  title =        "Reusing Convolutional Neural Network Models through
                 Modularization and Composition",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "70:1--70:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3632744",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3632744",
  abstract =     "With the widespread success of deep learning
                 technologies, many trained deep neural network (DNN)
                 models are now publicly available. However, directly
                 reusing the public DNN models for new tasks often fails
                 due to mismatching functionality or performance.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "70",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Misu:2024:SJB,
  author =       "Md Rakib Hossain Misu and Rohan Achar and Cristina V.
                 Lopes",
  title =        "{SourcererJBF}: a {Java} Build Framework For
                 Large-Scale Compilation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "71:1--71:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635710",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635710",
  abstract =     "Researchers and tool developers working on dynamic
                 analysis, software testing, automated program repair,
                 verification, and validation, need large compiled,
                 compilable, and executable code corpora to test their
                 ideas. The publicly available corpora are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "71",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:PAL,
  author =       "Zhihao Li and Chuanyi Li and Ze Tang and Wanhong Huang
                 and Jidong Ge and Bin Luo and Vincent Ng and Ting Wang
                 and Yucheng Hu and Xiaopeng Zhang",
  title =        "{PTM-APIRec}: Leveraging Pre-trained Models of Source
                 Code in {API} Recommendation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "72:1--72:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3632745",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3632745",
  abstract =     "Recommending APIs is a practical and essential feature
                 of IDEs. Improving the accuracy of API recommendations
                 is an effective way to improve coding efficiency. With
                 the success of deep learning in software engineering,
                 the state-of-the-art (SOTA) \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "72",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Biagiola:2024:TDR,
  author =       "Matteo Biagiola and Paolo Tonella",
  title =        "Testing of Deep Reinforcement Learning Agents with
                 Surrogate Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "73:1--73:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631970",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631970",
  abstract =     "Deep Reinforcement Learning (DRL) has received a lot
                 of attention from the research community in recent
                 years. As the technology moves away from game playing
                 to practical contexts, such as autonomous vehicles and
                 robotics, it is crucial to evaluate the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "73",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Giamattei:2024:CDT,
  author =       "Luca Giamattei and Antonio Guerriero and Roberto
                 Pietrantuono and Stefano Russo",
  title =        "Causality-driven Testing of Autonomous Driving
                 Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "74:1--74:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635709",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635709",
  abstract =     "Testing Autonomous Driving Systems (ADS) is essential
                 for safe development of self-driving cars. For thorough
                 and realistic testing, ADS are usually embedded in a
                 simulator and tested in interaction with the simulated
                 environment. However, their high \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "74",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2024:EAF,
  author =       "Weisong Sun and Chunrong Fang and Yuchen Chen and
                 Quanjun Zhang and Guanhong Tao and Yudu You and Tingxu
                 Han and Yifei Ge and Yuling Hu and Bin Luo and Zhenyu
                 Chen",
  title =        "An Extractive-and-Abstractive Framework for Source
                 Code Summarization",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "75:1--75:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3632742",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3632742",
  abstract =     "(Source) Code summarization aims to automatically
                 generate summaries/comments for given code snippets in
                 the form of natural language. Such summaries play a key
                 role in helping developers understand and maintain
                 source code. Existing code summarization \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "75",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Leeson:2024:ASS,
  author =       "Will Leeson and Matthew B. Dwyer",
  title =        "Algorithm Selection for Software Verification Using
                 Graph Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "76:1--76:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637225",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637225",
  abstract =     "The field of software verification has produced a wide
                 array of algorithmic techniques that can prove a
                 variety of properties of a given program. It has been
                 demonstrated that the performance of these techniques
                 can vary up to 4 orders of magnitude on the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "76",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Belgacem:2024:LBR,
  author =       "Hichem Belgacem and Xiaochen Li and Domenico Bianculli
                 and Lionel Briand",
  title =        "Learning-based Relaxation of Completeness Requirements
                 for Data Entry Forms",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "77:1--77:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635708",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635708",
  abstract =     "Data entry forms use completeness requirements to
                 specify the fields that are required or optional to
                 fill for collecting necessary information from
                 different types of users. However, because of the
                 evolving nature of software, some required fields may
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "77",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fu:2024:VTI,
  author =       "Michael Fu and Van Nguyen and Chakkrit
                 Tantithamthavorn and Dinh Phung and Trung Le",
  title =        "Vision Transformer Inspired Automated Vulnerability
                 Repair",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "78:1--78:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3632746",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3632746",
  abstract =     "Recently, automated vulnerability repair approaches
                 have been widely adopted to combat increasing software
                 security issues. In particular, transformer-based
                 encoder-decoder models achieve competitive results.
                 Whereas vulnerable programs may only consist \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "78",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2024:CVF,
  author =       "Pengfei Gao and Fu Song and Taolue Chen",
  title =        "Compositional Verification of First-Order Masking
                 Countermeasures against Power Side-Channel Attacks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "79:1--79:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635707",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635707",
  abstract =     "Power side-channel attacks allow an adversary to
                 efficiently and effectively steal secret information
                 (e.g., keys) by exploiting the correlation between
                 secret data and runtime power consumption, hence posing
                 a serious threat to software security, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "79",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pant:2024:EAA,
  author =       "Aastha Pant and Rashina Hoda and Simone V. Spiegler
                 and Chakkrit Tantithamthavorn and Burak Turhan",
  title =        "Ethics in the Age of {AI}: an Analysis of {AI}
                 Practitioners' Awareness and Challenges",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "80:1--80:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635715",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635715",
  abstract =     "Ethics in AI has become a debated topic of public and
                 expert discourse in recent years. But what do people
                 who build AI-AI practitioners-have to say about their
                 understanding of AI ethics and the challenges
                 associated with incorporating it into the AI-.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "80",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cederbladh:2024:EVV,
  author =       "Johan Cederbladh and Antonio Cicchetti and Jagadish
                 Suryadevara",
  title =        "Early Validation and Verification of System Behaviour
                 in Model-based Systems Engineering: a Systematic
                 Literature Review",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "81:1--81:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631976",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631976",
  abstract =     "In the Systems Engineering (SE) domain there has been
                 a paradigm shift from document-based to model-based
                 system development artefacts; in fact, new
                 methodologies are emerging to meet the increasing
                 complexity of current systems and the corresponding
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "81",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Russo:2024:UDWb,
  author =       "Daniel Russo and Paul H. P. Hanel and Niels van
                 Berkel",
  title =        "Understanding Developers Well-being and Productivity:
                 a 2-year Longitudinal Analysis during the {COVID-19}
                 {Pandemic-RCR} Report",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "3",
  pages =        "82:1--82:??",
  month =        mar,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640338",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 10 09:12:11 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640338",
  abstract =     "The artifact accompanying the paper ``Understanding
                 Developers Well-Being and Productivity: A 2-year
                 Longitudinal Analysis during the COVID-19 Pandemic''
                 provides a comprehensive set of tools, data, and
                 scripts that were utilized in the longitudinal study.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "82",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pezze:2024:EII,
  author =       "Mauro Pezz{\`e}",
  title =        "Editorial: {ICSE} and the Incredible Contradictions of
                 Software Engineering",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "83:1--83:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3656301",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3656301",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "83",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pan:2024:EEA,
  author =       "Weifeng Pan and Marouane Kessentini and Hua Ming and
                 Zijiang Yang",
  title =        "{EASE}: an Effort-aware Extension of Unsupervised Key
                 Class Identification Approaches",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "84:1--84:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635714",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635714",
  abstract =     "Key class identification approaches aim at identifying
                 the most important classes to help developers,
                 especially newcomers, start the software comprehension
                 process. So far, many supervised and unsupervised
                 approaches have been proposed; however, they \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "84",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Biringa:2024:PPA,
  author =       "Chidera Biringa and G{\"o}khan Kul",
  title =        "{PACE}: a Program Analysis Framework for Continuous
                 Performance Prediction",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "85:1--85:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637230",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637230",
  abstract =     "Software development teams establish elaborate
                 continuous integration pipelines containing automated
                 test cases to accelerate the development process of
                 software. Automated tests help to verify the
                 correctness of code modifications decreasing the
                 response \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "85",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2024:AET,
  author =       "Peng Zhang and Yang Wang and Xutong Liu and Zeyu Lu
                 and Yibiao Yang and Yanhui Li and Lin Chen and Ziyuan
                 Wang and Chang-Ai Sun and Xiao Yu and Yuming Zhou",
  title =        "Assessing Effectiveness of Test Suites: What Do We
                 Know and What Should We Do?",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "86:1--86:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635713",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635713",
  abstract =     "Background. Software testing is a critical activity
                 for ensuring the quality and reliability of software
                 systems. To evaluate the effectiveness of different
                 test suites, researchers have developed a variety of
                 metrics. Problem. However, comparing these \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "86",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ferrari:2024:UVB,
  author =       "Alessio Ferrari and Thaide Huichapa and Paola
                 Spoletini and Nicole Novielli and Davide Fucci and
                 Daniela Girardi",
  title =        "Using Voice and Biofeedback to Predict User Engagement
                 during Product Feedback Interviews",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "87:1--87:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635712",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635712",
  abstract =     "Capturing users' engagement is crucial for gathering
                 feedback about the features of a software product. In a
                 market-driven context, current approaches to collecting
                 and analyzing users' feedback are based on techniques
                 leveraging information extracted \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "87",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Karre:2024:RMV,
  author =       "Sai Anirudh Karre and Y. Raghu Reddy and Raghav
                 Mittal",
  title =        "{RE} Methods for Virtual Reality Software Product
                 Development: a Mapping Study",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "88:1--88:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649595",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649595",
  abstract =     "Software practitioners use various methods in
                 Requirements Engineering (RE) to elicit, analyze, and
                 specify the requirements of enterprise products. The
                 methods impact the final product characteristics and
                 influence product delivery. Ad-hoc usage of the
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "88",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2024:SSB,
  author =       "Zhe Chen and Rui Yan and Yingzi Ma and Yulei Sui and
                 Jingling Xue",
  title =        "A Smart Status Based Monitoring Algorithm for the
                 Dynamic Analysis of Memory Safety",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "89:1--89:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637227",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637227",
  abstract =     "C is a dominant programming language for implementing
                 system and low-level embedded software. Unfortunately,
                 the unsafe nature of its low-level control of memory
                 often leads to memory errors. Dynamic analysis has been
                 widely used to detect memory errors \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "89",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Canizares:2024:MCH,
  author =       "Pablo C. Ca{\~n}izares and Jose Mar{\'\i}a
                 L{\'o}pez-Morales and Sara P{\'e}rez-Soler and Esther
                 Guerra and Juan de Lara",
  title =        "Measuring and Clustering Heterogeneous Chatbot
                 Designs",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "90:1--90:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637228",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637228",
  abstract =     "Conversational agents, or chatbots, have become
                 popular to access all kind of software services. They
                 provide an intuitive natural language interface for
                 interaction, available from a wide range of channels
                 including social networks, web pages, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "90",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Oakes:2024:BDS,
  author =       "Bentley James Oakes and Michalis Famelis and Houari
                 Sahraoui",
  title =        "Building Domain-Specific Machine Learning Workflows: a
                 Conceptual Framework for the State of the Practice",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "91:1--91:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3638243",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3638243",
  abstract =     "Domain experts are increasingly employing machine
                 learning to solve their domain-specific problems. This
                 article presents to software engineering researchers
                 the six key challenges that a domain expert faces in
                 addressing their problem with a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "91",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shao:2024:ESR,
  author =       "Changjie Shao and Gaolei Li and Jun Wu and Xi Zheng",
  title =        "Exploring Semantic Redundancy using Backdoor Triggers:
                 a Complementary Insight into the Challenges Facing
                 {DNN}-based Software Vulnerability Detection",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "92:1--92:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640333",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640333",
  abstract =     "To detect software vulnerabilities with better
                 performance, deep neural networks (DNNs) have received
                 extensive attention recently. However, these
                 vulnerability detection DNN models trained with code
                 representations are vulnerable to specific \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "92",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jodat:2024:TGS,
  author =       "Baharin A. Jodat and Abhishek Chandar and Shiva Nejati
                 and Mehrdad Sabetzadeh",
  title =        "Test Generation Strategies for Building Failure Models
                 and Explaining Spurious Failures",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "93:1--93:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3638246",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3638246",
  abstract =     "Test inputs fail not only when the system under test
                 is faulty but also when the inputs are invalid or
                 unrealistic. Failures resulting from invalid or
                 unrealistic test inputs are spurious. Avoiding spurious
                 failures improves the effectiveness of testing
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "93",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Neelofar:2024:IES,
  author =       "Neelofar Neelofar and Aldeida Aleti",
  title =        "Identifying and Explaining Safety-critical Scenarios
                 for Autonomous Vehicles via Key Features",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "94:1--94:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640335",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640335",
  abstract =     "Ensuring the safety of autonomous vehicles (AVs) is of
                 utmost importance, and testing them in simulated
                 environments is a safer option than conducting in-field
                 operational tests. However, generating an exhaustive
                 test suite to identify critical test \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "94",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Clun:2024:RAM,
  author =       "Donato Clun and Donghwan Shin and Antonio Filieri and
                 Domenico Bianculli",
  title =        "Rigorous Assessment of Model Inference Accuracy using
                 Language Cardinality",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "95:1--95:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640332",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640332",
  abstract =     "Models such as finite state automata are widely used
                 to abstract the behavior of software systems by
                 capturing the sequences of events observable during
                 their execution. Nevertheless, models rarely exist in
                 practice and, when they do, get easily outdated;
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "95",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhou:2024:AFC,
  author =       "Anshunkang Zhou and Yikun Hu and Xiangzhe Xu and
                 Charles Zhang",
  title =        "{ARCTURUS}: Full Coverage Binary Similarity Analysis
                 with Reachability-guided Emulation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "96:1--96:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640337",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640337",
  abstract =     "Binary code similarity analysis is extremely useful,
                 since it provides rich information about an unknown
                 binary, such as revealing its functionality and
                 identifying reused libraries. Robust binary similarity
                 analysis is challenging, as heavy compiler \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "96",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2024:CDL,
  author =       "Kai Gao and Runzhi He and Bing Xie and Minghui Zhou",
  title =        "Characterizing Deep Learning Package Supply Chains in
                 {PyPI}: Domains, Clusters, and Disengagement",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "97:1--97:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640336",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640336",
  abstract =     "Deep learning (DL) frameworks have become the
                 cornerstone of the rapidly developing DL field. Through
                 installation dependencies specified in the distribution
                 metadata, numerous packages directly or transitively
                 depend on DL frameworks, layer after layer, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "97",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chowdhury:2024:MLB,
  author =       "Shaiful Chowdhury and Gias Uddin and Hadi Hemmati and
                 Reid Holmes",
  title =        "Method-level Bug Prediction: Problems and Promises",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "98:1--98:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640331",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640331",
  abstract =     "Fixing software bugs can be colossally expensive,
                 especially if they are discovered in the later phases
                 of the software development life cycle. As such, bug
                 prediction has been a classic problem for the research
                 community. As of now, the Google Scholar \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "98",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Song:2024:IPC,
  author =       "Qunying Song and Emelie Engstr{\"o}m and Per Runeson",
  title =        "Industry Practices for Challenging Autonomous Driving
                 Systems with Critical Scenarios",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "99:1--99:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640334",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640334",
  abstract =     "Testing autonomous driving systems for safety and
                 reliability is essential, yet complex. A primary
                 challenge is identifying relevant test scenarios,
                 especially the critical ones that may expose hazards or
                 harm to autonomous vehicles and other road users.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "99",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhu:2024:CAT,
  author =       "Mingxuan Zhu and Dan Hao and Junjie Chen",
  title =        "Compiler Autotuning through Multiple-phase Learning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "100:1--100:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640330",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640330",
  abstract =     "Widely used compilers like GCC and LLVM usually have
                 hundreds of optimizations controlled by optimization
                 flags, which are enabled or disabled during compilation
                 to improve the runtime performance (e.g., small
                 execution time) of the compiler program. Due \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "100",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{LoiolaDeSantana:2024:BAJ,
  author =       "Taijara {Loiola De Santana} and Paulo {Anselmo Da Mota
                 Silveira Neto} and Eduardo {Santana De Almeida} and
                 Iftekhar Ahmed",
  title =        "Bug Analysis in {Jupyter Notebook} Projects: an
                 Empirical Study",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "101:1--101:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641539",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641539",
  abstract =     "Computational notebooks, such as Jupyter, have been
                 widely adopted by data scientists to write code for
                 analyzing and visualizing data. Despite their growing
                 adoption and popularity, few studies have been found to
                 understand Jupyter development challenges \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "101",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:MAD,
  author =       "Zhenfei Huang and Junjie Chen and Jiajun Jiang and
                 Yihua Liang and Hanmo You and Fengjie Li",
  title =        "Mapping {APIs} in Dynamic-typed Programs by Leveraging
                 Transfer Learning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "102:1--102:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641848",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641848",
  abstract =     "Application Programming Interface (API) migration is a
                 common task for adapting software across different
                 programming languages and platforms, where manually
                 constructing the mapping relations between APIs is
                 indeed time-consuming and error-prone. To \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "102",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Kang:2024:DHM,
  author =       "Sungmin Kang and Robert Feldt and Shin Yoo",
  title =        "Deceiving Humans and Machines Alike: Search-based Test
                 Input Generation for {DNNs} Using Variational
                 Autoencoders",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "103:1--103:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3635706",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3635706",
  abstract =     "Due to the rapid adoption of Deep Neural Networks
                 (DNNs) into larger software systems, testing of
                 DNN-based systems has received much attention recently.
                 While many different test adequacy criteria have been
                 suggested, we lack effective test input \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "103",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2024:BAE,
  author =       "Han Wang and Sijia Yu and Chunyang Chen and Burak
                 Turhan and Xiaodong Zhu",
  title =        "Beyond Accuracy: an Empirical Study on Unit Testing in
                 Open-source Deep Learning Projects",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "104:1--104:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3638245",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3638245",
  abstract =     "Deep Learning (DL) models have rapidly advanced,
                 focusing on achieving high performance through testing
                 model accuracy and robustness. However, it is unclear
                 whether DL projects, as software systems, are tested
                 thoroughly or functionally correct when \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "104",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2024:EUL,
  author =       "Shikai Guo and Dongmin Li and Lin Huang and Sijia Lv
                 and Rong Chen and Hui Li and Xiaochen Li and He Jiang",
  title =        "Estimating Uncertainty in Labeled Changes by {SZZ}
                 Tools on Just-In-Time Defect Prediction",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "105:1--105:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637226",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637226",
  abstract =     "The aim of Just-In-Time (JIT) defect prediction is to
                 predict software changes that are prone to defects in a
                 project in a timely manner, thereby improving the
                 efficiency of software development and ensuring
                 software quality. Identifying changes that \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "105",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2024:SCC,
  author =       "Hanyang Guo and Yingye Chen and Xiangping Chen and
                 Yuan Huang and Zibin Zheng",
  title =        "Smart Contract Code Repair Recommendation based on
                 Reinforcement Learning and Multi-metric Optimization",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "106:1--106:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3637229",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3637229",
  abstract =     "A smart contract is a kind of code deployed on the
                 blockchain that executes automatically once an event
                 triggers a clause in the contract. Since smart
                 contracts involve businesses such as asset transfer,
                 they are more vulnerable to attacks, so it is
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "106",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Pizzolotto:2024:MDB,
  author =       "Davide Pizzolotto and Stefano Berlato and Mariano
                 Ceccato",
  title =        "Mitigating Debugger-based Attacks to {Java}
                 Applications with Self-debugging",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "107:1--107:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3631971",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3631971",
  abstract =     "Java bytecode is a quite high-level language and, as
                 such, it is fairly easy to analyze and decompile with
                 malicious intents, e.g., to tamper with code and skip
                 license checks. Code obfuscation was a first attempt to
                 mitigate malicious reverse-engineering \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "107",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:BAP,
  author =       "Puzhuo Liu and Yaowen Zheng and Chengnian Sun and Hong
                 Li and Zhi Li and Limin Sun",
  title =        "Battling against Protocol Fuzzing: Protecting
                 Networked Embedded Devices from Dynamic Fuzzers",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "108:1--108:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641847",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641847",
  abstract =     "Networked Embedded Devices (NEDs) are increasingly
                 targeted by cyberattacks, mainly due to their
                 widespread use in our daily lives. Vulnerabilities in
                 NEDs are the root causes of these cyberattacks.
                 Although deployed NEDs go through thorough code audits,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "108",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gunatilake:2024:EBE,
  author =       "Hashini Gunatilake and John Grundy and Rashina Hoda
                 and Ingo Mueller",
  title =        "Enablers and Barriers of Empathy in Software Developer
                 and User Interactions: a Mixed Methods Case Study",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "109:1--109:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641849",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641849",
  abstract =     "Software engineering (SE) requires developers to
                 collaborate with stakeholders, and understanding their
                 emotions and perspectives is often vital. Empathy is a
                 concept characterising a person's ability to understand
                 and share the feelings of another. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "109",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tan:2024:URT,
  author =       "Xin Tan and Xinyue Lv and Jing Jiang and Li Zhang",
  title =        "Understanding Real-Time Collaborative Programming: a
                 Study of {Visual Studio Live Share}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "110:1--110:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643672",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643672",
  abstract =     "Real-time collaborative programming (RCP) entails
                 developers working simultaneously, regardless of their
                 geographic locations. RCP differs from traditional
                 asynchronous online programming methods, such as Git or
                 SVN, where developers work independently \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "110",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2024:TOD,
  author =       "Qiang Hu and Yuejun Guo and Xiaofei Xie and Maxime
                 Cordy and Lei Ma and Mike Papadakis and Yves {Le
                 Traon}",
  title =        "Test Optimization in {DNN} Testing: a Survey",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "4",
  pages =        "111:1--111:??",
  month =        may,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643678",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Wed Apr 24 13:33:37 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643678",
  abstract =     "This article presents a comprehensive survey on test
                 optimization in deep neural network (DNN) testing.
                 Here, test optimization refers to testing with low data
                 labeling effort. We analyzed 90 papers, including 43
                 from the software engineering (SE) \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "111",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Robillard:2024:CSD,
  author =       "Martin P. Robillard and Deeksha M. Arya and Neil A.
                 Ernst and Jin L. C. Guo and Maxime Lamothe and Mathieu
                 Nassif and Nicole Novielli and Alexander Serebrenik and
                 Igor Steinmacher and Klaas-Jan Stol",
  title =        "Communicating Study Design Trade-offs in Software
                 Engineering",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "112:1--112:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649598",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649598",
  abstract =     "Reflecting on the limitations of a study is a crucial
                 part of the research process. In software engineering
                 studies, this reflection is typically conveyed through
                 discussions of study limitations or threats to
                 validity. In current practice, such \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "112",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ollando:2024:LFI,
  author =       "Rapha{\"e}l Ollando and Seung Yeob Shin and Lionel C.
                 Briand",
  title =        "Learning Failure-Inducing Models for Testing
                 Software-Defined Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "113:1--113:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641541",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641541",
  abstract =     "Software-defined networks (SDN) enable flexible and
                 effective communication systems that are managed by
                 centralized software controllers. However, such a
                 controller can undermine the underlying communication
                 network of an SDN-based system and thus must be
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "113",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gao:2024:SML,
  author =       "Cuifeng Gao and Wenzhang Yang and Jiaming Ye and
                 Yinxing Xue and Jun Sun",
  title =        "{sGuard+}: Machine Learning Guided Rule-Based
                 Automated Vulnerability Repair on Smart Contracts",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "114:1--114:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641846",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641846",
  abstract =     "Smart contracts are becoming appealing targets for
                 hackers because of the vast amount of cryptocurrencies
                 under their control. Asset loss due to the exploitation
                 of smart contract codes has increased significantly in
                 recent years. To guarantee that smart \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "114",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yang:2024:TSE,
  author =       "Lin Yang and Junjie Chen and Shutao Gao and Zhihao
                 Gong and Hongyu Zhang and Yue Kang and Huaan Li",
  title =        "Try with Simpler --- an Evaluation of Improved
                 Principal Component Analysis in Log-based Anomaly
                 Detection",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "115:1--115:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3644386",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3644386",
  abstract =     "With the rapid development of deep learning (DL), the
                 recent trend of log-based anomaly detection focuses on
                 extracting semantic information from log events (i.e.,
                 templates of log messages) and designing more advanced
                 DL models for anomaly detection. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "115",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:RCG,
  author =       "Yue Liu and Thanh Le-Cong and Ratnadira Widyasari and
                 Chakkrit Tantithamthavorn and Li Li and Xuan-Bach D. Le
                 and David Lo",
  title =        "Refining {ChatGPT}-Generated Code: Characterizing and
                 Mitigating Code Quality Issues",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "116:1--116:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643674",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643674",
  abstract =     "Since its introduction in November 2022, ChatGPT has
                 rapidly gained popularity due to its remarkable ability
                 in language understanding and human-like responses.
                 ChatGPT, based on GPT-3.5 architecture, has shown great
                 promise for revolutionizing various \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "116",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sulun:2024:EAI,
  author =       "Emre S{\"u}l{\"u}n and Metehan Sa{\c{c}}ak{\c{c}}i and
                 Eray T{\"u}z{\"u}n",
  title =        "An Empirical Analysis of Issue Templates Usage in
                 Large-Scale Projects on {GitHub}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "117:1--117:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643673",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643673",
  abstract =     "GitHub Issues is a widely used issue tracking tool in
                 open-source software projects. Originally designed with
                 broad flexibility, its lack of standardization led to
                 incomplete issue reports, impeding software development
                 and maintenance efficiency. To \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "117",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xia:2024:EVN,
  author =       "Xinmeng Xia and Yang Feng and Qingkai Shi and James A.
                 Jones and Xiangyu Zhang and Baowen Xu",
  title =        "Enumerating Valid Non-Alpha-Equivalent Programs for
                 Interpreter Testing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "118:1--118:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3647994",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3647994",
  abstract =     "Skeletal program enumeration (SPE) can generate a
                 great number of test programs for validating the
                 correctness of compilers or interpreters. The classic
                 SPE generates programs by exhaustively enumerating all
                 possible variable usage patterns into a given
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "118",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ren:2024:DTC,
  author =       "Jiawei Ren and Yulei Sui and Xiao Cheng and Yuan Feng
                 and Jianjun Zhao",
  title =        "Dynamic Transitive Closure-based Static Analysis
                 through the Lens of Quantum Search",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "119:1--119:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3644389",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3644389",
  abstract =     "Many existing static analysis algorithms suffer from
                 cubic bottlenecks because of the need to compute a
                 dynamic transitive closure (DTC). For the first time,
                 this article studies the quantum speedups on searching
                 subtasks in DTC-based static analysis \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "119",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:NAL,
  author =       "Fang Liu and Zhiyi Fu and Ge Li and Zhi Jin and Hui
                 Liu and Yiyang Hao and Li Zhang",
  title =        "Non-Autoregressive Line-Level Code Completion",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "120:1--120:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649594",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649594",
  abstract =     "Software developers frequently use code completion
                 tools to accelerate software development by suggesting
                 the following code elements. Researchers usually employ
                 AutoRegressive (AR) decoders to complete code sequences
                 in a left-to-right, token-by-token \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "120",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Miltenberger:2024:PEC,
  author =       "Marc Miltenberger and Steven Arzt",
  title =        "Precisely Extracting Complex Variable Values from
                 {Android} Apps",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "121:1--121:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649591",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649591",
  abstract =     "Millions of users nowadays rely on their smartphones
                 to process sensitive data through apps from various
                 vendors and sources. Therefore, it is vital to assess
                 these apps for security vulnerabilities and privacy
                 violations. Information such as to which \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "121",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhao:2024:DTA,
  author =       "Yu Zhao and Brent Harrison and Tingting Yu",
  title =        "{DinoDroid}: Testing {Android} Apps Using Deep
                 {Q}-Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "122:1--122:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652150",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652150",
  abstract =     "The large demand of mobile devices creates significant
                 concerns about the quality of mobile applications
                 (apps). Developers need to guarantee the quality of
                 mobile apps before it is released to the market. There
                 have been many approaches using different \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "122",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guo:2024:GPT,
  author =       "Yimeng Guo and Zhifei Chen and Lin Chen and Wenjie Xu
                 and Yanhui Li and Yuming Zhou and Baowen Xu",
  title =        "Generating {Python} Type Annotations from Type
                 Inference: How Far Are We?",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "123:1--123:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652153",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652153",
  abstract =     "In recent years, dynamic languages such as Python have
                 become popular due to their flexibility and
                 productivity. The lack of static typing makes programs
                 face the challenges of fixing type errors, early bug
                 detection, and code understanding. To alleviate
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "123",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cheng:2024:PSL,
  author =       "Yu Cheng and Jieshan Chen and Qing Huang and Zhenchang
                 Xing and Xiwei Xu and Qinghua Lu",
  title =        "Prompt Sapper: a {LLM}-Empowered Production Tool for
                 Building {AI} Chains",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "124:1--124:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3638247",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3638247",
  abstract =     "The emergence of foundation models, such as large
                 language models (LLMs) GPT-4 and text-to-image models
                 DALL-E, has opened up numerous possibilities across
                 various domains. People can now use natural language
                 (i.e., prompts) to communicate with AI to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "124",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2024:MTT,
  author =       "Quanjun Zhang and Juan Zhai and Chunrong Fang and
                 Jiawei Liu and Weisong Sun and Haichuan Hu and Qingyu
                 Wang",
  title =        "Machine Translation Testing via Syntactic Tree
                 Pruning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "125:1--125:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3640329",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3640329",
  abstract =     "Machine translation systems have been widely adopted
                 in our daily life, making life easier and more
                 convenient. Unfortunately, erroneous translations may
                 result in severe consequences, such as financial
                 losses. This requires to improve the accuracy and
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "125",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:REL,
  author =       "Yue Liu and Chakkrit Tantithamthavorn and Yonghui Liu
                 and Li Li",
  title =        "On the Reliability and Explainability of Language
                 Models for Program Generation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "126:1--126:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641540",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641540",
  abstract =     "Recent studies have adopted pre-trained language
                 models, such as CodeT5 and CodeGPT, for automated
                 program generation tasks like code generation, repair,
                 and translation. Numerous language model based
                 approaches have been proposed and evaluated on various
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "126",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Cheng:2024:BFE,
  author =       "Baijun Cheng and Shengming Zhao and Kailong Wang and
                 Meizhen Wang and Guangdong Bai and Ruitao Feng and Yao
                 Guo and Lei Ma and Haoyu Wang",
  title =        "Beyond Fidelity: Explaining Vulnerability Localization
                 of Learning-Based Detectors",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "127:1--127:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641543",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641543",
  abstract =     "Vulnerability detectors based on deep learning (DL)
                 models have proven their effectiveness in recent years.
                 However, the shroud of opacity surrounding the
                 decision-making process of these detectors makes it
                 difficult for security analysts to comprehend.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "127",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fan:2024:RZS,
  author =       "Guodong Fan and Shizhan Chen and Cuiyun Gao and
                 Jianmao Xiao and Tao Zhang and Zhiyong Feng",
  title =        "{RAPID}: Zero-Shot Domain Adaptation for Code Search
                 with Pre-Trained Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "128:1--128:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3641542",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3641542",
  abstract =     "Code search, which refers to the process of
                 identifying the most relevant code snippets for a given
                 natural language query, plays a crucial role in
                 software maintenance. However, current approaches
                 heavily rely on labeled data for training, which
                 results \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "128",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:ART,
  author =       "Jiaxiang Liu and Yunhan Xing and Xiaomu Shi and Fu
                 Song and Zhiwu Xu and Zhong Ming",
  title =        "Abstraction and Refinement: Towards Scalable and Exact
                 Verification of Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "129:1--129:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3644387",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3644387",
  abstract =     "As a new programming paradigm, deep neural networks
                 (DNNs) have been increasingly deployed in practice, but
                 the lack of robustness hinders their applications in
                 safety-critical domains. While there are techniques for
                 verifying DNNs with formal guarantees, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "129",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Attaoui:2024:SSA,
  author =       "Mohammed Oualid Attaoui and Hazem Fahmy and Fabrizio
                 Pastore and Lionel Briand",
  title =        "Supporting Safety Analysis of Image-processing {DNNs}
                 through Clustering-based Approaches",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "130:1--130:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643671",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643671",
  abstract =     "The adoption of deep neural networks (DNNs) in
                 safety-critical contexts is often prevented by the lack
                 of effective means to explain their results, especially
                 when they are erroneous. In our previous work, we
                 proposed a white-box approach (HUDD) and a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "130",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Shang:2024:ADI,
  author =       "Xiuwei Shang and Shuai Zhang and Yitong Zhang and
                 Shikai Guo and Yulong Li and Rong Chen and Hui Li and
                 Xiaochen Li and He Jiang",
  title =        "Analyzing and Detecting Information Types of Developer
                 Live Chat Threads",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "131:1--131:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643677",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643677",
  abstract =     "Online chatrooms serve as vital platforms for
                 information exchange among software developers. With
                 multiple developers engaged in rapid communication and
                 diverse conversation topics, the resulting chat
                 messages often manifest complexity and lack \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "131",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:TIP,
  author =       "Yinghua Li and Xueqi Dang and Lei Ma and Jacques Klein
                 and Yves {Le Traon} and Tegawend{\'e} F.
                 Bissyand{\'e}",
  title =        "Test Input Prioritization for {$3$D} Point Clouds",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "132:1--132:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643676",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643676",
  abstract =     "3D point cloud applications have become increasingly
                 prevalent in diverse domains, showcasing their efficacy
                 in various software systems. However, testing such
                 applications presents unique challenges due to the
                 high-dimensional nature of 3D point cloud \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "132",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Tao:2024:KKA,
  author =       "Wei Tao and Yucheng Zhou and Yanlin Wang and Hongyu
                 Zhang and Haofen Wang and Wenqiang Zhang",
  title =        "{KADEL}: Knowledge-Aware Denoising Learning for Commit
                 Message Generation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "133:1--133:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3643675",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3643675",
  abstract =     "Commit messages are natural language descriptions of
                 code changes, which are important for software
                 evolution such as code understanding and maintenance.
                 However, previous methods are trained on the entire
                 dataset without considering the fact that a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "133",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hommersom:2024:AMV,
  author =       "Daan Hommersom and Antonino Sabetta and Bonaventura
                 Coppola and Dario {Di Nucci} and Damian A. Tamburri",
  title =        "Automated Mapping of Vulnerability Advisories onto
                 their Fix Commits in Open Source Repositories",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "134:1--134:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649590",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649590",
  abstract =     "The lack of comprehensive sources of accurate
                 vulnerability data represents a critical obstacle to
                 studying and understanding software vulnerabilities
                 (and their corrections). In this article, we present an
                 approach that combines heuristics stemming from
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "134",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Russo:2024:NCG,
  author =       "Daniel Russo",
  title =        "Navigating the Complexity of Generative {AI} Adoption
                 in Software Engineering",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "135:1--135:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652154",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652154",
  abstract =     "This article explores the adoption of Generative
                 Artificial Intelligence (AI) tools within the domain of
                 software engineering, focusing on the influencing
                 factors at the individual, technological, and social
                 levels. We applied a convergent mixed-methods
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "135",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Betz:2024:LLD,
  author =       "Stefanie Betz and Birgit Penzenstadler and Leticia
                 Duboc and Ruzanna Chitchyan and Sedef Akinli Kocak and
                 Ian Brooks and Shola Oyedeji and Jari Porras and
                 Norbert Seyff and Colin C. Venters",
  title =        "Lessons Learned from Developing a Sustainability
                 Awareness Framework for Software Engineering Using
                 Design Science",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "136:1--136:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649597",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649597",
  abstract =     "To foster a sustainable society within a sustainable
                 environment, we must dramatically reshape our work and
                 consumption activities, most of which are facilitated
                 through software. Yet, most software engineers hardly
                 consider the effects on the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "136",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2024:FTC,
  author =       "Zhenpeng Chen and Jie M. Zhang and Max Hort and Mark
                 Harman and Federica Sarro",
  title =        "Fairness Testing: a Comprehensive Survey and Analysis
                 of Trends",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "137:1--137:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652155",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652155",
  abstract =     "Unfair behaviors of Machine Learning (ML) software
                 have garnered increasing attention and concern among
                 software engineers. To tackle this issue, extensive
                 research has been dedicated to conducting fairness
                 testing of ML software, and this article offers
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "137",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2024:FGCa,
  author =       "Wei-Cheng Wu and Bernard Nongpoh and Marwan Nour and
                 Micha{\"e}l Marcozzi and S{\'e}bastien Bardin and
                 Christophe Hauser",
  title =        "Fine-grained Coverage-based Fuzzing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "138:1--138:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3587158",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3587158",
  abstract =     "Fuzzing is a popular software testing method that
                 discovers bugs by massively feeding target applications
                 with automatically generated inputs. Many
                 state-of-the-art fuzzers use branch coverage as a
                 feedback metric to guide the fuzzing process. The
                 fuzzer \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "138",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wu:2024:FGCb,
  author =       "Wei-Cheng Wu and Bernard Nongpoh and Marwan Nour and
                 Micha{\"e}l Marcozzi and S{\'e}bastien Bardin and
                 Christophe Hauser",
  title =        "Fine-grained Coverage-based Fuzzing --- {RCR} Report",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "5",
  pages =        "139:1--139:??",
  month =        jun,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649592",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Fri Jun 7 08:54:10 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649592",
  abstract =     "This is the RCR report of the artifact for the article
                 ``Fine-grained Coverage-based Fuzzing.'' This report
                 contains scripts and pre-build binary programs to
                 reproduce the results presented in the main article.
                 The artifact is released on Zenodo with DOI: \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "139",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Chen:2024:RDT,
  author =       "Zhifei Chen and Lin Chen and Yibiao Yang and Qiong
                 Feng and Xuansong Li and Wei Song",
  title =        "Risky Dynamic Typing-related Practices in {Python}: an
                 Empirical Study",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "140:1--140:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649593",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649593",
  abstract =     "Python's dynamic typing nature provides developers
                 with powerful programming abstractions. However, many
                 type-related bugs are accumulated in code bases of
                 Python due to the misuse of dynamic typing. The goal of
                 this article is to aid in the understanding \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "140",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wan:2024:DCN,
  author =       "Xiaohui Wan and Zheng Zheng and Fangyun Qin and Xuhui
                 Lu",
  title =        "Data Complexity: a New Perspective for Analyzing the
                 Difficulty of Defect Prediction Tasks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "141:1--141:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3649596",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3649596",
  abstract =     "Defect prediction is crucial for software quality
                 assurance and has been extensively researched over
                 recent decades. However, prior studies rarely focus on
                 data complexity in defect prediction tasks, and even
                 less on understanding the difficulties of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "141",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Arcuri:2024:AWB,
  author =       "Andrea Arcuri and Man Zhang and Juan Galeotti",
  title =        "Advanced White-Box Heuristics for Search-Based Fuzzing
                 of {REST APIs}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "142:1--142:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652157",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652157",
  abstract =     "Due to its importance and widespread use in industry,
                 automated testing of REST APIs has attracted major
                 interest from the research community in the last few
                 years. However, most of the work in the literature has
                 been focused on black-box fuzzing. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "142",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Guglielmi:2024:HTU,
  author =       "Emanuela Guglielmi and Giovanni Rosa and Simone
                 Scalabrino and Gabriele Bavota and Rocco Oliveto",
  title =        "Help Them Understand: Testing and Improving Voice User
                 Interfaces",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "143:1--143:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654438",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654438",
  abstract =     "Voice-based virtual assistants are becoming
                 increasingly popular. Such systems provide frameworks
                 to developers for building custom apps. End-users can
                 interact with such apps through a Voice User Interface
                 (VUI), which allows the user to use natural \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "143",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Perera:2024:ILR,
  author =       "Anjana Perera and Burak Turhan and Aldeida Aleti and
                 Marcel B{\"o}hme",
  title =        "On the Impact of Lower Recall and Precision in Defect
                 Prediction for Guiding Search-based Software Testing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "144:1--144:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3655022",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3655022",
  abstract =     "Defect predictors, static bug detectors, and humans
                 inspecting the code can propose locations in the
                 program that are more likely to be buggy before they
                 are discovered through testing. Automated test
                 generators such as search-based software testing
                 (SBST). \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "144",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zhang:2024:EFS,
  author =       "Guofu Zhang and Lei Li and Zhaopin Su and Feng Yue and
                 Yang Chen and Miqing Li and Xin Yao",
  title =        "On Estimating the Feasible Solution Space of
                 Multi-objective Testing Resource Allocation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "145:1--145:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654444",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654444",
  abstract =     "The multi-objective testing resource allocation
                 problem (MOTRAP) is concerned on how to reasonably plan
                 the testing time of software testers to save the cost
                 and improve the reliability as much as possible. The
                 feasible solution space of a MOTRAP is \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "145",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Iannone:2024:ERE,
  author =       "Emanuele Iannone and Giulia Sellitto and Emanuele
                 Iaccarino and Filomena Ferrucci and Andrea {De Lucia}
                 and Fabio Palomba",
  title =        "Early and Realistic Exploitability Prediction of
                 Just-Disclosed Software Vulnerabilities: How Reliable
                 Can It Be?",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "146:1--146:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654443",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654443",
  abstract =     "With the rate of discovered and disclosed
                 vulnerabilities escalating, researchers have been
                 experimenting with machine learning to predict whether
                 a vulnerability will be exploited. Existing solutions
                 leverage information unavailable when a CVE is
                 created,. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "146",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Long:2024:TMS,
  author =       "Peixun Long and Jianjun Zhao",
  title =        "Testing Multi-Subroutine Quantum Programs: From Unit
                 Testing to Integration Testing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "147:1--147:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3656339",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3656339",
  abstract =     "Quantum computing has emerged as a promising field
                 with the potential to revolutionize various domains by
                 harnessing the principles of quantum mechanics. As
                 quantum hardware and algorithms continue to advance,
                 developing high-quality quantum software has \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "147",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2024:MTL,
  author =       "Xu Wang and Hongwei Yu and Xiangxin Meng and Hongliang
                 Cao and Hongyu Zhang and Hailong Sun and Xudong Liu and
                 Chunming Hu",
  title =        "{MTL-TRANSFER}: Leveraging Multi-task Learning and
                 Transferred Knowledge for Improving Fault Localization
                 and Program Repair",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "148:1--148:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654441",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654441",
  abstract =     "Fault localization (FL) and automated program repair
                 (APR) are two main tasks of automatic software
                 debugging. Compared with traditional methods, deep
                 learning-based approaches have been demonstrated to
                 achieve better performance in FL and APR tasks.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "148",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Bi:2024:WSI,
  author =       "Tingting Bi and Boming Xia and Zhenchang Xing and
                 Qinghua Lu and Liming Zhu",
  title =        "On the Way to {SBOMs}: Investigating Design Issues and
                 Solutions in Practice",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "149:1--149:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654442",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654442",
  abstract =     "The increase of software supply chain threats has
                 underscored the necessity for robust security
                 mechanisms, among which the Software Bill of Materials
                 (SBOM) stands out as a promising solution. SBOMs, by
                 providing a machine-readable inventory of software
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "149",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2024:MSA,
  author =       "Congying Xu and Valerio Terragni and Hengcheng Zhu and
                 Jiarong Wu and Shing-Chi Cheung",
  title =        "{MR-Scout}: Automated Synthesis of Metamorphic
                 Relations from Existing Test Cases",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "150:1--150:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3656340",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3656340",
  abstract =     "Metamorphic Testing (MT) alleviates the oracle problem
                 by defining oracles based on metamorphic relations
                 (MRs) that govern multiple related inputs and their
                 outputs. However, designing MRs is challenging, as it
                 requires domain-specific knowledge. This \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "150",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Abualhaija:2024:RRE,
  author =       "Sallam Abualhaija and F. Basak Aydemir and Fabiano
                 Dalpiaz and Davide Dell'Anna and Alessio Ferrari and
                 Xavier Franch and Davide Fucci",
  title =        "Replication in Requirements Engineering: The {NLP} for
                 {RE} Case",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "151:1--151:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3658669",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3658669",
  abstract =     "Natural language processing (NLP) techniques have been
                 widely applied in the requirements engineering (RE)
                 field to support tasks such as classification and
                 ambiguity detection. Despite its empirical vocation, RE
                 research has given limited attention to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "151",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zohdinasab:2024:FTG,
  author =       "Tahereh Zohdinasab and Vincenzo Riccio and Paolo
                 Tonella",
  title =        "Focused Test Generation for Autonomous Driving
                 Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "152:1--152:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664605",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664605",
  abstract =     "Testing Autonomous Driving Systems (ADSs) is crucial
                 to ensure their reliability when navigating complex
                 environments. ADSs may exhibit unexpected behaviours
                 when presented, during operation, with driving
                 scenarios containing features inadequately \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "152",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Madampe:2024:SEI,
  author =       "Kashumi Madampe and Rashina Hoda and John Grundy",
  title =        "Supporting Emotional Intelligence, Productivity and
                 Team Goals while Handling Software Requirements
                 Changes",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "153:1--153:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664600",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664600",
  abstract =     "Background: Research shows that emotional intelligence
                 (EI) should be used alongside cognitive intelligence
                 during requirements change (RC) handling in Software
                 Engineering (SE), especially in agile settings.
                 Objective: We wanted to study the role of EI \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "153",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:ARQ,
  author =       "Yuechen Li and Hanyu Pei and Linzhi Huang and Beibei
                 Yin and Kai-Yuan Cai",
  title =        "Automatic Repair of Quantum Programs via Unitary
                 Operation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "154:1--154:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664604",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664604",
  abstract =     "With the continuous advancement of quantum computing
                 (QC), the demand for high-quality quantum programs
                 (QPs) is growing. To avoid program failure, in software
                 engineering, the technology of automatic program repair
                 (APR) employs appropriate patches to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "154",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ngo:2024:TUA,
  author =       "Chanh Duc Ngo and Fabrizio Pastore and Lionel Briand",
  title =        "Testing Updated Apps by Adapting Learned Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "155:1--155:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664601",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664601",
  abstract =     "Although App updates are frequent and software
                 engineers would like to verify updated features only,
                 automated testing techniques verify entire Apps and are
                 thus wasting resources. We present Continuous
                 Adaptation of Learned Models (CALM), an automated
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "155",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2024:FTM,
  author =       "Zeyu Sun and Zhenpeng Chen and Jie Zhang and Dan Hao",
  title =        "Fairness Testing of Machine Translation Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "156:1--156:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664608",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664608",
  abstract =     "Machine translation is integral to international
                 communication and extensively employed in diverse
                 human-related applications. Despite remarkable
                 progress, fairness issues persist within current
                 machine translation systems. In this article, we
                 propose \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "156",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2024:MAO,
  author =       "Siyu Jiang and Zhenhang He and Yuwen Chen and Mingrong
                 Zhang and Le Ma",
  title =        "Mobile Application Online Cross-Project Just-in-Time
                 Software Defect Prediction Framework",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "157:1--157:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664607",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664607",
  abstract =     "As mobile applications evolve rapidly, their fast
                 iterative update nature leads to an increase in
                 software defects. Just-In-Time Software Defect
                 Prediction (JIT-SDP) offers immediate feedback on code
                 changes. For new applications without historical data,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "157",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Aghababaeyan:2024:DMO,
  author =       "Zohreh Aghababaeyan and Manel Abdellatif and Mahboubeh
                 Dadkhah and Lionel Briand",
  title =        "{DeepGD}: a Multi-Objective Black-{Box} Test Selection
                 Approach for Deep Neural Networks",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "158:1--158:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3644388",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3644388",
  abstract =     "Deep neural networks (DNNs) are widely used in various
                 application domains such as image processing, speech
                 recognition, and natural language processing. However,
                 testing DNN models may be challenging due to the
                 complexity and size of their input domain. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "158",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:RIT,
  author =       "Zhen Li and Shasha Zhao and Chen Chen and Qian Chen",
  title =        "Reducing the Impact of Time Evolution on Source Code
                 Authorship Attribution via Domain Adaptation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "159:1--159:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652151",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652151",
  abstract =     "Source code authorship attribution is an important
                 problem in practical applications such as plagiarism
                 detection, software forensics, and copyright disputes.
                 Recent studies show that existing methods for source
                 code authorship attribution can be \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "159",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ding:2024:DCS,
  author =       "Xi Ding and Rui Peng and Xiangping Chen and Yuan Huang
                 and Jing Bian and Zibin Zheng",
  title =        "Do Code Summarization Models Process Too Much
                 Information? Function Signature May Be All That Is
                 Needed",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "160:1--160:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3652156",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3652156",
  abstract =     "With the fast development of large software projects,
                 automatic code summarization techniques, which
                 summarize the main functionalities of a piece of code
                 using natural languages as comments, play essential
                 roles in helping developers understand and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "160",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ramos:2024:BRL,
  author =       "Daniel Ramos and In{\^e}s Lynce and Vasco Manquinho
                 and Ruben Martins and Claire {Le Goues}",
  title =        "{BatFix}: Repairing language model-based
                 transpilation",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "161:1--161:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3658668",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3658668",
  abstract =     "To keep up with changes in requirements, frameworks,
                 and coding practices, software organizations might need
                 to migrate code from one language to another.
                 Source-to-source migration, or transpilation, is often
                 a complex, manual process. Transpilation \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "161",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Nguyen:2024:DDA,
  author =       "Van Nguyen and Trung Le and Chakkrit Tantithamthavorn
                 and John Grundy and Dinh Phung",
  title =        "Deep Domain Adaptation With Max-Margin Principle for
                 Cross-Project Imbalanced Software Vulnerability
                 Detection",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "162:1--162:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664602",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664602",
  abstract =     "Software vulnerabilities (SVs) have become a common,
                 serious, and crucial concern due to the ubiquity of
                 computer software. Many AI-based approaches have been
                 proposed to solve the software vulnerability detection
                 (SVD) problem to ensure the security and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "162",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Hu:2024:EGE,
  author =       "Han Hu and Han Wang and Ruiqi Dong and Xiao Chen and
                 Chunyang Chen",
  title =        "Enhancing {GUI} Exploration Coverage of {Android} Apps
                 with Deep Link-Integrated Monkey",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "163:1--163:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664810",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664810",
  abstract =     "Mobile apps are ubiquitous in our daily lives for
                 supporting different tasks such as reading and
                 chatting. Despite the availability of many GUI testing
                 tools, app testers still struggle with low testing code
                 coverage due to tools frequently getting stuck
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "163",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gavidia-Calderon:2024:IUI,
  author =       "Carlos Gavidia-Calderon and Anastasia Kordoni and Amel
                 Bennaceur and Mark Levine and Bashar Nuseibeh",
  title =        "The {IDEA} of Us: an Identity-Aware Architecture for
                 Autonomous Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "164:1--164:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3654439",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3654439",
  abstract =     "Autonomous systems, such as drones and rescue robots,
                 are increasingly used during emergencies. They deliver
                 services and provide situational awareness that
                 facilitate emergency management and response. To do so,
                 they need to interact and cooperate with \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "164",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2024:WMG,
  author =       "Haoye Wang and Zhipeng Gao and Tingting Bi and John
                 Grundy and Xinyu Wang and Minghui Wu and Xiaohu Yang",
  title =        "What Makes a Good {TODO} Comment?",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "165:1--165:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664811",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664811",
  abstract =     "Software development is a collaborative process that
                 involves various interactions among individuals and
                 teams. TODO comments in source code play a critical
                 role in managing and coordinating diverse tasks during
                 this process. However, this study finds \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "165",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Sun:2024:SSC,
  author =       "Weisong Sun and Chunrong Fang and Yifei Ge and Yuling
                 Hu and Yuchen Chen and Quanjun Zhang and Xiuting Ge and
                 Yang Liu and Zhenyu Chen",
  title =        "A Survey of Source Code Search: a $3$-Dimensional
                 Perspective",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "6",
  pages =        "166:1--166:??",
  month =        jul,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3656341",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:15 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3656341",
  abstract =     "(Source) code search is widely concerned by software
                 engineering researchers because it can improve the
                 productivity and quality of software development. Given
                 a functionality requirement usually described in a
                 natural language sentence, a code search \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "166",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wan:2024:KAT,
  author =       "Chengcheng Wan and Shicheng Liu and Sophie Xie and
                 Yuhan Liu and Henry Hoffmann and Michael Maire and Shan
                 Lu",
  title =        "Keeper: Automated Testing and Fixing of Machine
                 Learning Software",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "167:1--167:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672451",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672451",
  abstract =     "The increasing number of software applications
                 incorporating machine learning (ML) solutions has led
                 to the need for testing techniques. However, testing ML
                 software requires tremendous human effort to design
                 realistic and relevant test inputs and to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "167",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Fungprasertkul:2024:TDM,
  author =       "Suwichak Fungprasertkul and Rami Bahsoon and Rick
                 Kazman",
  title =        "Technical Debt Monitoring Decision Making with Skin in
                 the Game",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "168:1--168:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664805",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664805",
  abstract =     "Technical Debt Management (TDM) can suffer from
                 unpredictability, communication gaps and the
                 inaccessibility of relevant information, which hamper
                 the effectiveness of its decision making. These issues
                 can stem from division among decision-makers which
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "168",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ma:2024:UCP,
  author =       "Wei Ma and Shangqing Liu and Mengjie Zhao and Xiaofei
                 Xie and Wenhang Wang and Qiang Hu and Jie Zhang and
                 Yang Liu",
  title =        "Unveiling Code Pre-Trained Models: Investigating
                 Syntax and Semantics Capacities",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "169:1--169:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664606",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664606",
  abstract =     "Code models have made significant advancements in code
                 intelligence by encoding knowledge about programming
                 languages. While previous studies have explored the
                 capabilities of these models in learning code syntax,
                 there has been limited investigation on \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "169",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2024:UVI,
  author =       "Muhui Jiang and Jinan Jiang and Tao Wu and Zuchao Ma
                 and Xiapu Luo and Yajin Zhou",
  title =        "Understanding Vulnerability Inducing Commits of the
                 {Linux} Kernel",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "170:1--170:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672452",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/linux.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672452",
  abstract =     "The Linux kernel is popular and well-maintained. Over
                 the past decade, around 860 thousand commits were
                 merged with hundreds of vulnerabilities (i.e., 223 on
                 average) disclosed every year, taking the total lines
                 of code to 35.1 million in 2022. Many algorithms have
                 been proposed to detect the vulnerabilities, but few
                 studied how they were induced. To fill this gap, we
                 conduct the first empirical study on the Kernel
                 Vulnerability Inducing Commits (KVIC), the commits that
                 induced vulnerabilities in the Linux kernel. We
                 utilized six different methods on identifying the
                 Kernel Vulnerability Fixing Commits (KVFCs), the
                 commits that fix vulnerabilities in the Linux kernel,
                 and proposed the other four different methods for
                 identifying KVICs by using the identified KVFCs as a
                 bridge. In total, we constructed the first dataset of
                 KVICs with 1,240 KVICs for 1,335 CVEs. We conducted a
                 thorough analysis on the characteristics, purposes, and
                 involved human factors of the KVICs and obtained many
                 interesting findings and insights. For example, KVICs
                 usually have limited reviewers and can still be induced
                 by experienced authors or maintainers. Based on these
                 insights, we proposed several suggestions to the Linux
                 community to help mitigate the induction of KVICs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "170",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dejon:2024:CQP,
  author =       "Nicolas Dejon and Chrystel Gaber and Gilles Grimaud
                 and Narjes Jomaa",
  title =        "Code to Qed, the Project Manager's Guide to Proof
                 Engineering",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "171:1--171:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664807",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664807",
  abstract =     "Despite growing efforts and encouraging successes in
                 recent decades, fully formally verified projects are
                 still rare in the industrial landscape. The industry
                 often lacks the tools and methodologies to efficiently
                 scale the proof development process. In \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "171",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Mahdavi-Hezaveh:2024:PPC,
  author =       "Rezvan Mahdavi-Hezaveh and Sameeha Fatima and Laurie
                 Williams",
  title =        "Paving a Path for a Combined Family of Feature Toggle
                 and Configuration Option Research",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "172:1--172:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672555",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672555",
  abstract =     "Feature toggles and configuration options are
                 techniques to include or exclude functionality in
                 software. The research contributions to these two
                 techniques have most often been focused on either one
                 of them. However, focusing on the similarities of these
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "172",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Gu:2024:SVM,
  author =       "Rong Gu and Eduard Baranov and Afshin Ameri and
                 Cristina Seceleanu and Eduard Paul Enoiu and Baran
                 C{\"u}r{\"u}kl{\"u} and Axel Legay and Kristina
                 Lundqvist",
  title =        "Synthesis and Verification of Mission Plans for
                 Multiple Autonomous Agents under Complex Road
                 Conditions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "173:1--173:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672445",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672445",
  abstract =     "Mission planning for multi-agent autonomous systems
                 aims to generate feasible and optimal mission plans
                 that satisfy given requirements. In this article, we
                 propose a tool-supported mission-planning methodology
                 that combines (i) a path-planning algorithm \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "173",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Li:2024:MLM,
  author =       "Yao Li and Dawei Yuan and Tao Zhang and Haipeng Cai
                 and David Lo and Cuiyun Gao and Xiapu Luo and He
                 Jiang",
  title =        "Meta-Learning for Multi-Family {Android} Malware
                 Classification",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "174:1--174:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664806",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664806",
  abstract =     "With the emergence of smartphones, Android has become
                 a widely used mobile operating system. However, it is
                 vulnerable when encountering various types of attacks.
                 Every day, new malware threatens the security of users'
                 devices and private data. Many \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "174",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yu:2024:EPI,
  author =       "Shengcheng Yu and Chunrong Fang and Xin Li and Yuchen
                 Ling and Zhenyu Chen and Zhendong Su",
  title =        "Effective, Platform-Independent {GUI} Testing via
                 Image Embedding and Reinforcement Learning",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "175:1--175:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3674728",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3674728",
  abstract =     "Software applications (apps) have been playing an
                 increasingly important role in various aspects of
                 society. In particular, mobile apps and web apps are
                 the most prevalent among all applications and are
                 widely used in various industries as well as in
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "175",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lee:2024:ATL,
  author =       "Jaeseong Lee and Simin Chen and Austin Mordahl and
                 Cong Liu and Wei Yang and Shiyi Wei",
  title =        "Automated Testing Linguistic Capabilities of {NLP}
                 Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "176:1--176:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672455",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672455",
  abstract =     "Natural language processing (NLP) has gained
                 widespread adoption in the development of real-world
                 applications. However, the black-box nature of neural
                 networks in NLP applications poses a challenge when
                 evaluating their performance, let alone ensuring
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "176",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Perera:2024:SMS,
  author =       "Judith Perera and Ewan Tempero and Yu-Cheng Tu and
                 Kelly Blincoe",
  title =        "A Systematic Mapping Study Exploring Quantification
                 Approaches to Code, Design, and Architecture Technical
                 Debt",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "177:1--177:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3675393",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3675393",
  abstract =     "To effectively manage Technical Debt (TD), we need
                 reliable means to quantify it. We conducted a
                 Systematic Mapping Study (SMS) where we identified 39
                 quantification approaches for Code, Design, and
                 Architecture TD. We analyzed concepts and metrics
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "177",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Freire:2024:CVT,
  author =       "S{\'a}vio Freire and Alexia Pacheco and Nicolli Rios
                 and Boris P{\'e}rez and Camilo Castellanos and
                 Dar{\'\i}o Correal and Robert Ramac and Vladimir
                 Mandi{\'c} and Nebojsa Tausan and Gustavo L{\'o}pez and
                 Manoel Mendon{\c{c}}a and Davide Falessi and Clemente
                 Izurieta and Carolyn Seaman and Rodrigo Sp{\'\i}nola",
  title =        "A Comprehensive View on {TD} Prevention Practices and
                 Reasons for Not Preventing It",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "178:1--178:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3674727",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3674727",
  abstract =     "Context. Technical debt (TD) prevention allows
                 software practitioners to apply practices to avoid
                 potential TD items in their projects. Aims. To uncover
                 and prioritize, from the point of view of software
                 practitioners, the practices that could be used to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "178",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Zolduoarrati:2024:HCE,
  author =       "Elijah Zolduoarrati and Sherlock A. Licorish and Nigel
                 Stanger",
  title =        "Harmonising Contributions: Exploring Diversity in
                 Software Engineering through {CQA} Mining on {Stack
                 Overflow}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "179:1--179:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672453",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672453",
  abstract =     "The need for collective intelligence in technology
                 means that online Q\&A platforms, such as Stack
                 Overflow and Reddit, have become invaluable in building
                 the global knowledge ecosystem. Despite literature
                 demonstrating a prevalence of inclusion and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "179",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lou:2024:WAP,
  author =       "Yiling Lou and Jun Yang and Samuel Benton and Dan Hao
                 and Lin Tan and Zhenpeng Chen and Lu Zhang and Lingming
                 Zhang",
  title =        "When Automated Program Repair Meets Regression Testing
                 --- An Extensive Study on Two Million Patches",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "180:1--180:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672450",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672450",
  abstract =     "In recent years, Automated Program Repair (APR) has
                 been extensively studied in academia and even drawn
                 wide attention from the industry. However, APR
                 techniques can be extremely time consuming since (1) a
                 large number of patches can be generated for a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "180",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Liu:2024:ESC,
  author =       "Wei Liu and Shouvick Mondal and Tse-Hsun (Peter)
                 Chen",
  title =        "An Empirical Study on the Characteristics of Database
                 Access Bugs in {Java} Applications",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "181:1--181:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672449",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672449",
  abstract =     "Database-backed applications rely on the database
                 access code to interact with the underlying database
                 management systems (DBMSs). Although many prior studies
                 aim at database access issues like SQL anti-patterns or
                 SQL code smells, there is a lack of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "181",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Jiang:2024:SPC,
  author =       "Xue Jiang and Yihong Dong and Lecheng Wang and Zheng
                 Fang and Qiwei Shang and Ge Li and Zhi Jin and Wenpin
                 Jiao",
  title =        "Self-Planning Code Generation with Large Language
                 Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "182:1--182:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672456",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672456",
  abstract =     "Although large language models (LLMs) have
                 demonstrated impressive ability in code generation,
                 they are still struggling to address the complicated
                 intent provided by humans. It is widely acknowledged
                 that humans typically employ planning to decompose
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "182",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:RUA,
  author =       "Qing Huang and Zhiwen Luo and Zhenchang Xing and
                 Jinshan Zeng and Jieshan Chen and Xiwei Xu and Yong
                 Chen",
  title =        "Revealing the Unseen: {AI} Chain on {LLMs} for
                 Predicting Implicit Dataflows to Generate Dataflow
                 Graphs in Dynamically Typed Code",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "183:1--183:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672458",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672458",
  abstract =     "Dataflow graphs (DFGs) capture definitions (defs) and
                 uses across program blocks, which is a fundamental
                 program representation for program analysis, testing
                 and maintenance. However, dynamically typed programming
                 languages like Python present implicit \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "183",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Lyu:2024:MUS,
  author =       "Yingzhe Lyu and Heng Li and Zhen Ming (Jack) Jiang and
                 Ahmed E. Hassan",
  title =        "On the Model Update Strategies for Supervised Learning
                 in {AIOps} Solutions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "184:1--184:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664599",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664599",
  abstract =     "AIOps (Artificial Intelligence for IT Operations)
                 solutions leverage the massive data produced during the
                 operation of large-scale systems and machine learning
                 models to assist software engineers in their system
                 operations. As operation data produced in \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "184",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Xu:2024:GDD,
  author =       "Hang Xu and Liheng Chen and Shuitao Gan and Chao Zhang
                 and Zheming Li and Jiangan Ji and Baojian Chen and Fan
                 Hu",
  title =        "{Graphuzz}: Data-driven Seed Scheduling for
                 Coverage-guided Greybox Fuzzing",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "185:1--185:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664603",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664603",
  abstract =     "Seed scheduling is a critical step of greybox fuzzing,
                 which assigns different weights to seed test cases
                 during seed selection, and significantly impacts the
                 efficiency of fuzzing. Existing seed scheduling
                 strategies rely on manually designed models to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "185",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Feng:2024:LUT,
  author =       "Xiaoning Feng and Xiaohong Han and Simin Chen and Wei
                 Yang",
  title =        "{LLMEffiChecker}: Understanding and Testing Efficiency
                 Degradation of Large Language Models",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "186:1--186:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664812",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664812",
  abstract =     "Large Language Models (LLMs) have received much recent
                 attention due to their human-level accuracy. While
                 existing works mostly focus on either improving
                 accuracy or testing accuracy robustness, the
                 computation efficiency of LLMs, which is of paramount
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "186",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Yu:2024:FEJ,
  author =       "Jinqiang Yu and Michael Fu and Alexey Ignatiev and
                 Chakkrit Tantithamthavorn and Peter Stuckey",
  title =        "A Formal Explainer for Just-In-Time Defect
                 Predictions",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "187:1--187:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664809",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664809",
  abstract =     "Just-in-Tim e (JIT) defect prediction has been
                 proposed to help teams prioritize the limited resources
                 on the most risky commits (or pull requests), yet it
                 remains largely a black box, whose predictions are not
                 explainable or actionable to practitioners. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "187",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Huang:2024:NSG,
  author =       "Dong Huang and Qingwen Bu and Yichao Fu and Yuhao Qing
                 and Xiaofei Xie and Junjie Chen and Heming Cui",
  title =        "Neuron Sensitivity-Guided Test Case Selection",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "188:1--188:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672454",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672454",
  abstract =     "Deep neural networks (DNNs) have been widely deployed
                 in software to address various tasks (e.g., autonomous
                 driving, medical diagnosis). However, they can also
                 produce incorrect behaviors that result in financial
                 losses and even threaten human safety. To \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "188",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Dong:2024:SCC,
  author =       "Yihong Dong and Xue Jiang and Zhi Jin and Ge Li",
  title =        "Self-Collaboration Code Generation via {ChatGPT}",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "189:1--189:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672459",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672459",
  abstract =     "Although large language models (LLMs) have
                 demonstrated remarkable code-generation ability, they
                 still struggle with complex tasks. In real-world
                 software development, humans usually tackle complex
                 tasks through collaborative teamwork, a strategy that
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "189",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Wang:2024:CCC,
  author =       "Zhiyu Wang and Sihan Xu and Lingling Fan and Xiangrui
                 Cai and Linyu Li and Zheli Liu",
  title =        "Can Coverage Criteria Guide Failure Discovery for
                 Image Classifiers? {An} Empirical Study",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "190:1--190:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672446",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672446",
  abstract =     "Quality assurance of deep neural networks (DNNs) is
                 crucial for the deployment of DNN-based software,
                 especially in mission- and safety-critical tasks.
                 Inspired by structural white-box testing in traditional
                 software, many test criteria have been proposed
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "190",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Ye:2024:FFO,
  author =       "Mingxi Ye and Yuhong Nan and Hong-Ning Dai and Shuo
                 Yang and Xiapu Luo and Zibin Zheng",
  title =        "{FunFuzz}: a Function-Oriented Fuzzer for Smart
                 Contract Vulnerability Detection with High
                 Effectiveness and Efficiency",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "191:1--191:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3674725",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3674725",
  abstract =     "With the increasing popularity of Decentralized
                 Applications (DApps) in blockchain, securing smart
                 contracts has been a long-term, high-priority subject
                 in the domain. Among the various research directions
                 for vulnerability detection, fuzzing has received
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "191",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Peng:2024:BBS,
  author =       "Anni Peng and Dongliang Fang and Le Guan and Erik van
                 der Kouwe and Yin Li and Wenwen Wang and Limin Sun and
                 Yuqing Zhang",
  title =        "Bitmap-Based Security Monitoring for Deeply Embedded
                 Systems",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "192:1--192:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3672460",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3672460",
  abstract =     "Deeply embedded systems powered by microcontrollers
                 are becoming popular with the emergence of
                 Internet-of-Things (IoT) technology. However, these
                 devices primarily run C/C \({+}{+}\) code and are
                 susceptible to memory bugs, which can potentially lead
                 to \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "192",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Karas:2024:TTC,
  author =       "Zachary Karas and Aakash Bansal and Yifan Zhang and
                 Toby Li and Collin McMillan and Yu Huang",
  title =        "A Tale of Two Comprehensions? {Analyzing} Student
                 Programmer Attention during Code Summarization",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "193:1--193:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3664808",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3664808",
  abstract =     "Code summarization is the task of creating short,
                 natural language descriptions of source code. It is an
                 important part of code comprehension and a powerful
                 method of documentation. Previous work has made
                 progress in identifying where programmers focus in
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "193",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}

@Article{Parra-Calderon:2024:IIH,
  author =       "Carlos Parra-Calder{\'o}n and Juli{\'a}n Alberto
                 Garc{\'\i}a-Garc{\'\i}a and Juan Manuel Ramos-Cueli and
                 Celia Alvarez-Romero and Esther Rom{\'a}n-Villar{\'a}n
                 and Alicia Mart{\'\i}nez-Garc{\'\i}a and Mar{\'\i}a
                 Jos{\'e} Escalona",
  title =        "{IDE 4 ICDS}: a Human-Centric and Model-Driven
                 Proposal to Improve the Digitization of Clinical
                 Practice Guideline",
  journal =      j-TOSEM,
  volume =       "33",
  number =       "7",
  pages =        "194:1--194:??",
  month =        sep,
  year =         "2024",
  CODEN =        "ATSMER",
  DOI =          "https://doi.org/10.1145/3674732",
  ISSN =         "1049-331X (print), 1557-7392 (electronic)",
  ISSN-L =       "1049-331X",
  bibdate =      "Mon Sep 30 08:52:18 MDT 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/tosem.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3674732",
  abstract =     "Clinical practice guidelines (CPGs) are a
                 formalization of specific clinical knowledge that
                 states the best evidence-based clinical practices for
                 treating pathologies. However, CPGs are limited because
                 they are usually expressed as text. This gives rise
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Softw. Eng. Methodol.",
  articleno =    "194",
  fjournal =     "ACM Transactions on Software Engineering and
                 Methodology",
  journal-URL =  "https://dl.acm.org/loi/tosem",
}