@Preamble{"\input bibnames.sty" #
"\ifx \undefined \emph \def \emph #1{{{\em #1\/}}} \fi"
}
@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/|"}
@String{j-TOSEM = "ACM Transactions on Software Engineering and
Methodology"}
@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",
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",
}
