Valid HTML 4.0! Valid CSS!
%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author-1        = "Preston Briggs",
%%%     author-2        = "Nelson H. F. Beebe",
%%%     version         = "2.152",
%%%     date            = "23 December 2023",
%%%     time            = "05:59:26 MST",
%%%     filename        = "toplas.bib",
%%%     address-1       = "Tera Computer Company
%%%                        2815 Eastlake East
%%%                        Seattle, WA 98102
%%%                        USA",
%%%     address-2       = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone-1     = "+1 206 325-0800",
%%%     telephone-2     = "+1 801 581 5254",
%%%     FAX-2           = "+1 801 581 4148",
%%%     URL-2           = "https://www.math.utah.edu/~beebe",
%%%     checksum        = "43902 48398 239373 2401185",
%%%     email-1         = "preston at tera.com (Internet)",
%%%     email-2         = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "bibliography, BibTeX, ACM Transactions on
%%%                        Programming Languages and Systems, TOPLAS",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This is a COMPLETE bibliography of the journal
%%%                        ACM Transactions on Programming Languages and
%%%                        Systems (CODEN ATPSDT, ISSN 0164-0925
%%%                        (print), 1558-4593 (electronic)), informally
%%%                        known as TOPLAS.
%%%
%%%                        The publisher maintains World Wide Web sites
%%%                        for this journal at
%%%
%%%                            http://www.acm.org/pubs/contents/journals/toplas/
%%%                            http://portal.acm.org/browse_dl.cfm?idx=J783
%%%                            https://dl.acm.org/loi/toplas
%%%
%%%                        At version 2.152, the year coverage looked
%%%                        like this:
%%%
%%%                             1979 (  20)    1994 (  66)    2009 (  23)
%%%                             1980 (  33)    1995 (  39)    2010 (  21)
%%%                             1981 (  28)    1996 (  29)    2011 (  21)
%%%                             1982 (  39)    1997 (  35)    2012 (  17)
%%%                             1983 (  36)    1998 (  34)    2013 (  14)
%%%                             1984 (  34)    1999 (  32)    2014 (  14)
%%%                             1985 (  34)    2000 (  28)    2015 (  17)
%%%                             1986 (  26)    2001 (  17)    2016 (  13)
%%%                             1987 (  27)    2002 (  21)    2017 (  16)
%%%                             1988 (  32)    2003 (  20)    2018 (  19)
%%%                             1989 (  30)    2004 (  28)    2019 (  23)
%%%                             1990 (  28)    2005 (  33)    2020 (  15)
%%%                             1991 (  30)    2006 (  27)    2021 (  21)
%%%                             1992 (  22)    2007 (  45)    2022 (  26)
%%%                             1993 (  32)    2008 (  33)    2023 (  22)
%%%
%%%                             Article:       1219
%%%                             TechReport:       1
%%%
%%%                             Total entries: 1220
%%%
%%%                        This bibliography was initially constructed
%%%                        by hand by the first author (PB) from
%%%                        various sources, and at its last release in
%%%                        February 1995, had 447 entries.
%%%
%%%                        It was further extended by the second
%%%                        author (NHFB) using bibliographies in
%%%                        NHFB's personal files, from the OCLC
%%%                        Contents1st database, from the IEEE INSPEC
%%%                        database, from the computer graphics
%%%                        bibliography archive at ftp.siggraph.org,
%%%                        and from the computer science bibliography
%%%                        collection on ftp.ira.uka.de in
%%%                        /pub/bibliography to which many people of
%%%                        have contributed.  The snapshot of this
%%%                        collection was taken on 5-May-1994, and it
%%%                        consists of 441 BibTeX files, 2,672,675
%%%                        lines, 205,289 entries, and 6,375
%%%                        <at>String{} abbreviations, occupying
%%%                        94.8MB of disk space.  This work updated 85
%%%                        existing entries and added 104 new entries,
%%%                        completing coverage to for all issues up to
%%%                        Volume 17, Number 5, September 1995.
%%%
%%%                        Numerous errors in the sources noted above
%%%                        have been corrected.  Spelling has been
%%%                        verified with the UNIX spell and GNU ispell
%%%                        programs using the exception dictionary
%%%                        stored in the companion file with extension
%%%                        .sok.
%%%
%%%                        The ACM maintains Web pages with journal
%%%                        tables of contents for 1985--1995 at
%%%                        http://www.acm.org/pubs/toc.  That data has
%%%                        been automatically converted to BibTeX
%%%                        form, corrected for spelling and page
%%%                        number errors, and merged into this file.
%%%
%%%                        ACM copyrights explicitly permit abstracting
%%%                        with credit, so article abstracts, keywords,
%%%                        and subject classifications have been
%%%                        included in this bibliography wherever
%%%                        available.  Article reviews have been
%%%                        omitted, until their copyright status has
%%%                        been clarified.
%%%
%%%                        bibsource keys in the bibliography entries
%%%                        below indicate the entry originally came
%%%                        from the computer science bibliography
%%%                        archive, even though it has likely since
%%%                        been corrected and updated.
%%%
%%%                        URL keys in the bibliography point to
%%%                        World Wide Web locations of additional
%%%                        information about the entry.
%%%
%%%                        BibTeX citation tags are uniformly chosen as
%%%                        name:year:abbrev, where name is the family
%%%                        name of the first author or editor, year is a
%%%                        4-digit number, and abbrev is a 3-letter
%%%                        condensation of important title
%%%                        words. Citation tags were automatically
%%%                        generated by software developed for the
%%%                        BibNet Project.
%%%
%%%                        In this bibliography, entries are sorted in
%%%                        publication order, using bibsort -byvolume.
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================
@Preamble{
    "\hyphenation{
        Fa-la-schi
        Her-men-e-gil-do
        Lu-ba-chev-sky
        Pu-ru-sho-tha-man
        Roe-ver
        Ros-en-krantz
        Ru-dolph
    }" #
    "\ifx \undefined \circled \def \circled #1{(#1)}\fi" #
    "\ifx \undefined \reg \def \reg {\circled{R}}\fi"
}

%%% ====================================================================
%%% Acknowledgement abbreviations:
@String{ack-meo =  "Melissa E. O'Neill,
                    School of Computing Science,
                    Simon Fraser University,
                    Burnaby, BC,
                    Canada V5A 1S6,
                    e-mail: \path|oneill@cs.sfu.ca|,
                    URL: \path|http://www.cs.sfu.ca/people/GradStudents/oneill/|"}

@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{ack-pb =    "Preston Briggs,
                     Tera Computer Company,
                     2815 Eastlake East,
                     Seattle, WA 98102,
                     USA,
                     Tel: +1 206 325-0800,
                     e-mail: \path|preston@tera.com|"}

%%% ====================================================================
%%% Journal abbreviations:
@String{j-TOPLAS                = "ACM Transactions on Programming
                                  Languages and Systems"}

%%% ====================================================================
%%% Bibliography entries:
@TechReport{Morgan:1988:RC,
  author =       "C. C. Morgan and K. A. Robinson and P. H. B.
                 Gardiner",
  title =        "On the Refinement Calculus",
  type =         "Technical Monograph",
  number =       "PRG-70",
  institution =  "Oxford University Computing Laboratory",
  address =      "Wolfson Building, Parks Road, Oxford, UK",
  month =        oct,
  year =         "1988",
  ISBN =         "0-902928-52-X",
  ISBN-13 =      "978-0-902928-52-7",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  length =       "151",
}

@Article{Lindstrom:1979:BGC,
  author =       "Gary Lindstrom",
  title =        "Backtracking in a Generalized Control Setting",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "8--26",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dewar:1979:PRE,
  author =       "Robert B. K. Dewar and Arthur Grand and Ssu-Cheng Liu
                 and Jacob T. Schwartz and Edmond Schonberg",
  title =        "Programming by Refinement, as Exemplified by the
                 {SETL} Representation Sublanguage",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "27--49",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sites:1979:CLI,
  author =       "Richard L. Sites",
  title =        "The Compilation of Loop Induction Expressions",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "50--57",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ghezzi:1979:IP,
  author =       "Carlo Ghezzi and Dino Mandrioli",
  title =        "Incremental Parsing",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "58--70",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 11:06:56 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Robertson:1979:CGS,
  author =       "Edward L. Robertson",
  title =        "Code Generation and Storage Allocation for Machines
                 with Span-Dependent Instructions",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "71--83",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lamport:1979:NAP,
  author =       "Leslie Lamport",
  title =        "A New Approach to Proving the Correctness of
                 Multiprocess Programs",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "84--97",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/357062.357068",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:02:18 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See also corrigendum \cite{Lamport:1980:CNA}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Constable:1979:HAF,
  author =       "Robert L. Constable and James E. Donahue",
  title =        "A Hierarchical Approach to Formal Semantics With
                 Application to the Definition of {PL\slash CS}",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "98--114",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 18:36:35 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wise:1979:MGC,
  author =       "David S. Wise",
  title =        "{Morris}'s Garbage Compaction Algorithm Restores
                 Reference Counts",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "115--120",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lengauer:1979:FAF,
  author =       "Thomas Lengauer and Robert Endre Tarjan",
  title =        "A Fast Algorithm for Finding Dominators in a
                 Flowgraph",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "121--141",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kennedy:1979:DAG,
  author =       "Ken Kennedy and Jayashree Ramanathan",
  title =        "A Deterministic Attribute Grammar Evaluator Based on
                 Dynamic Scheduling",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "1",
  pages =        "142--160",
  month =        jul,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Parallel/scheduling.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Iverson:1979:O,
  author =       "Kenneth E. Iverson",
  title =        "Operators",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "161--176",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Perrott:1979:LAV,
  author =       "R. H. Perrott",
  title =        "A Language for Array and Vector Processors",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "177--195",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Prywes:1979:UNS,
  author =       "N. S. Prywes and Amir Pnueli and S. Shastry",
  title =        "Use of a Nonprocedural Specification Language and
                 Associated Program Generator in Software Development",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "196--217",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kieburtz:1979:CCS,
  author =       "Richard B. Kieburtz and Abraham Silberschatz",
  title =        "Comments on ``{Communicating} Sequential Processes''",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "218--225",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Luckham:1979:VAR,
  author =       "David C. Luckham and Norihisa Suzuki",
  title =        "Verification of Array, Record, and Pointer Operations
                 in {Pascal}",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "226--244",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nelson:1979:SCD,
  author =       "Greg Nelson and Derek C. Oppen",
  title =        "Simplification by Cooperating Decision Procedures",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "245--257",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/Constr.logic.prog.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gries:1979:SEB,
  author =       "David Gries",
  title =        "Is Sometimes Ever Better Than Alway?",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "258--265",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bobrow:1979:CEL,
  author =       "Daniel G. Bobrow and Douglas W. Clark",
  title =        "Compact Encodings of List Structure",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "266--286",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  comment =      "Good words on {CDR}-coding",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Beyer:1979:SED,
  author =       "Eric Beyer and Peter Buneman",
  title =        "A Space Efficient Dynamic Allocation Algorithm for
                 Queuing Messages",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "287--294",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tai:1979:NSG,
  author =       "Kou-Chung Tai",
  title =        "Noncanonical {SLR}(1) Grammars",
  journal =      j-TOPLAS,
  volume =       "1",
  number =       "2",
  pages =        "295--320",
  month =        oct,
  year =         "1979",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Harel:1980:PNA,
  author =       "David Harel",
  title =        "{And/Or} Programs: a New Approach to Structured
                 Programming",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "1--17",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pai:1980:GCR,
  author =       "Ajit B. Pai and Richard B. Kieburtz",
  title =        "Global Context Recovery: a New Strategy for Syntactic
                 Error Recovery by Table-Drive Parsers",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "18--41",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Francez:1980:DT,
  author =       "Nissim Francez",
  title =        "Distributed Termination",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "42--55",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:02:21 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See also corrigendum \cite{Francez:1980:CDT} and
                 remarks \cite{Mohan:1981:TCF,Francez:1981:TCR}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Andrews:1980:AAI,
  author =       "Gregory R. Andrews and Richard P. Reitman",
  title =        "An Axiomatic Approach to Information Flow in
                 Programs",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "56--76",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Papadimitriou:1980:PBH,
  author =       "Christos H. Papadimitriou and Philip A. Bernstein",
  title =        "On the Performance of Balanced Hashing Functions When
                 the Keys Are Not Equiprobable",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "77--89",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/hash.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Manna:1980:DAP,
  author =       "Zohar Manna and Richard Waldinger",
  title =        "A Deductive Approach to Program Synthesis",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "90--121",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Arnold:1980:URG,
  author =       "D. B. Arnold and M. R. Sleep",
  title =        "Uniform Random Generation of Balanced Parenthesis
                 Strings",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "122--128",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Comer:1980:NMS,
  author =       "Douglas Comer",
  title =        "A Note on Median Split Trees",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "129--133",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lamport:1980:CNA,
  author =       "Leslie Lamport",
  title =        "Corrigendum: ``{A New Approach to Proving the
                 Correctness of Multiprocess Programs}''",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "1",
  pages =        "134--134",
  month =        jan,
  year =         "1980",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/357084.357093",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:53:34 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Lamport:1979:NAP}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wallis:1980:ERO,
  author =       "Peter J. L. Wallis",
  title =        "External Representations of Objects of User-Defined
                 Type",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "137--152",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See also corrigendum \cite{Wallis:1981:CER}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Griswold:1980:AUP,
  author =       "Ralph E. Griswold and David R. Hanson",
  title =        "An Alternative to the Use of Patterns in String
                 Processing",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "153--172",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cattell:1980:ADC,
  author =       "R. G. G. Cattell",
  title =        "Automatic Derivation of Code Generators from Machine
                 Descriptions",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "173--190",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Davidson:1980:DAR,
  author =       "Jack W. Davidson and Christopher W. Fraser",
  title =        "The Design and Application of a Retargetable Peephole
                 Optimizer",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "191--202",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:02:24 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See also corrigendum \cite{Davidson:1981:CDA}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fischer:1980:PCA,
  author =       "Charles N. Fischer",
  title =        "On Parsing and Compiling Arithmetic Expressions on
                 Vector Computers",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "203--224",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Luckham:1980:AEH,
  author =       "David C. Luckham and W. Polak",
  title =        "{Ada} exception handling: an axiomatic approach",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "225--233",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bernstein:1980:OGN,
  author =       "Arthur Bernstein",
  title =        "Output Guards and Nondeterminism in ``{Communicating
                 Sequential Processes}''",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "234--238",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/ProbAlgs.bib",
  note =         "Bernstein presents a distributed algorithm for CSP
                 output guards based on priority ordering of
                 processes.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ma:1980:DMI,
  author =       "Perng-Ti Ma and T. G. Lewis",
  title =        "Design of a Machine-Independent Optimizing System for
                 Emulator Development",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "2",
  pages =        "239--262",
  month =        apr,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bobrow:1980:MRS,
  author =       "Daniel G. Bobrow",
  title =        "Managing Reentrant Structures Using Reference Counts",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "269--273",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leverett:1980:CSD,
  author =       "Bruce W. Leverett and Thomas G. Szymanski",
  title =        "Chaining Span-Dependent Jump Instructions",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "274--289",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Samet:1980:CAP,
  author =       "Hanan Samet",
  title =        "A Coroutine Approach to Parsing",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "290--306",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Howden:1980:ASV,
  author =       "W. E. Howden",
  title =        "Applicability of Software Validation Techniques to
                 Scientific Programs",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "307--320",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Broy:1980:DIA,
  author =       "Manfred Broy and Bernd Krieg-{Br{\"u}ckner}",
  title =        "Derivation of Invariant Assertions During Program
                 Development by Transformation",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "321--337",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Clarke:1980:SRI,
  author =       "Edmund Melson {Clarke, Jr.}",
  title =        "Synthesis of Resource Invariants for Concurrent
                 Programs",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "338--358",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Apt:1980:PSC,
  author =       "Krzysztof R. Apt and Nissim Francez and Willem P. de
                 Roever",
  title =        "A Proof System for Communicating Sequential
                 Processes",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "359--385",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:22:43 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remarks \cite{Moitra:1983:TCA}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Casanova:1980:FSR,
  author =       "Marco R. Casanova and Phillip A. Bernstein",
  title =        "A Formal System for Reasoning about Programs Accessing
                 a Relational Database",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "386--414",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Graham:1980:ICF,
  author =       "Susan L. Graham and Michael A. Harrison and Walter L.
                 Ruzzo",
  title =        "An Improved Context-Free Recognizer",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "415--462",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Francez:1980:CDT,
  author =       "Nissim Francez",
  title =        "Corrigendum: ``{Distributed Termination}''",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "3",
  pages =        "463--463",
  month =        jul,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:55:53 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See
                 \cite{Francez:1980:DT,Mohan:1981:TCF,Francez:1981:TCR}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Oppen:1980:P,
  author =       "Dereck C. Oppen",
  title =        "Prettyprinting",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "465--483",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Schwartz:1980:U,
  author =       "Jacob T. Schwartz",
  title =        "Ultracomputers",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "484--521",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ernst:1980:SAD,
  author =       "George W. Ernst and William F. Ogden",
  title =        "Specification of Abstract Data Types in {Modula}",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "522--543",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Landwehr:1980:ATS,
  author =       "Carl E. Landwehr",
  title =        "An Abstract Type for Statistics Collection in
                 {Simula}",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "544--563",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gries:1980:APC,
  author =       "David Gries and Gary Levin",
  title =        "Assignment and Procedure Call Proof Rules",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "564--579",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moret:1980:AVR,
  author =       "B. M. E. Moret and M. G. Thomason and R. C. Gonzalez",
  title =        "The Activity of a Variable and Its Relation to
                 Decision Trees",
  journal =      j-TOPLAS,
  volume =       "2",
  number =       "4",
  pages =        "580--595",
  month =        oct,
  year =         "1980",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Steensgaard-Madsen:1981:SOA,
  author =       "J. Steensgaard-Madsen",
  title =        "A Statement-Oriented Approach to Data Abstraction",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "1--10",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remarks
                 \cite{Ellis:1982:TCS,Steensgaard-Madsen:1982:TCS}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Andre:1981:MAC,
  author =       "F. {Andr{\'e}} and J. P. Banatre and J. P. Routeau",
  title =        "A Multiprocessing Approach to Compile-Time Symbol
                 Resolution",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "11--23",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Juelich:1981:CAS,
  author =       "Otto C. Juelich and Clinton R. Foulk",
  title =        "Compilation of Acyclic Smooth Programs for Parallel
                 Execution",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "24--48",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grit:1981:DIT,
  author =       "Dale H. Grit and Rex L. Page",
  title =        "Deleting Irrelevant Tasks in an Expression-Oriented
                 Multiprocessor System",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "49--59",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kristensen:1981:MCL,
  author =       "Bent Bruun Kristensen and Ole Lehrmann Madsen",
  title =        "Methods for Computing {LALR$ (k) $} Lookahead",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "60--82",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{LaLonde:1981:HOP,
  author =       "Wilf R. LaLonde and Jim des Rivieres",
  title =        "Handling Operator Precedence in Arithmetic Expressions
                 with Tree Transformations",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "83--103",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:17:11 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remarks
                 \cite{Henderson:1983:TCL,LaLonde:1983:TCL}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Misra:1981:EPE,
  author =       "Jayadev Misra",
  title =        "An Exercise in Program Explanation",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "104--109",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Davidson:1981:CDA,
  author =       "Jack W. Davidson and Christopher W. Fraser",
  title =        "Corrigendum: ``{The Design and Application of a
                 Retargetable Peephole Optimizer}''",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "110--110",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Davidson:1980:DAR}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wallis:1981:CER,
  author =       "Peter J. L. Wallis",
  title =        "Corrigendum: ``{External Representations of Objects of
                 User-Defined Type}''",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "111--111",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Wallis:1980:ERO}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Mohan:1981:TCF,
  author =       "C. Mohan",
  title =        "Technical Correspondence: On {Francez}'s
                 ``{Distributed Termination}''",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "112--112",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Francez:1980:DT,Francez:1981:TCR}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Francez:1981:TCR,
  author =       "N. Francez",
  title =        "Technical Correspondence: Reply from {Francez}",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "1",
  pages =        "112--113",
  month =        jan,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:05:53 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Francez:1980:DT,Mohan:1981:TCF}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fraser:1981:EDS,
  author =       "Christopher W. Fraser and A. A. Lopez",
  title =        "Editing Data Structures",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "2",
  pages =        "115--125",
  month =        apr,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/lisp.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Schonberg:1981:ATS,
  author =       "Edmond Schonberg and Jacob T. Schwartz and Micha
                 Sharir",
  title =        "An Automatic Technique for Selection of Data
                 Structures in {SETL} Programs",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "2",
  pages =        "126--143",
  month =        apr,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/Graefe.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "SETL is a very high level programming language
                 supporting set theoretic syntax and semantics. It
                 allows algorithms to be programmed rapidly and
                 succinctly without requiring data structure
                 declarations to be supplied. Such declarations can be
                 manually specified later, without recoding the program,
                 to improve the efficiency of program execution. We
                 describe a new technique for automatic selection of
                 appropriate data representations during compile time
                 for programs with omitted declarations and present an
                 efficient data representation selection algorithm,
                 whose complexity is comparable with those of the
                 fastest known general data-flow algorithms of Tarjan
                 and Reif.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "New York Univ. bit vector direct representation
                 pointer array for subsets",
}

@Article{Griswold:1981:GI,
  author =       "Ralph E. Griswold and David R. Hanson and John T.
                 Korb",
  title =        "Generators in {Icon}",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "2",
  pages =        "144--161",
  month =        apr,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hanson:1981:APP,
  author =       "David R. Hanson",
  title =        "{Algorithm 568}. {PDS} --- a Portable Directory
                 System",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "2",
  pages =        "162--167",
  month =        apr,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 9 14:11:06 1994",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://doi.acm.org/10.1145/357133.357137",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{LaLonde:1981:CSC,
  author =       "Wilf R. LaLonde",
  title =        "The Construction of Stack-Controlling {LR} Parsers for
                 Regular Right Part Grammars",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "2",
  pages =        "168--206",
  month =        apr,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gannon:1981:DAI,
  author =       "John Gannon and Paul McMullin and Richard Hamlet",
  title =        "Data Abstraction, Implementation, Specification, and
                 Testing",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "211--223",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{vandenBos:1981:PCB,
  author =       "Jan {van den Bos} and R. Plasmeijer and Jan W. M.
                 Stroet",
  title =        "Process Communication Based on Input Specifications",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "224--250",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Oct 31 06:37:56 2003",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Nierstrasz.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "uilit",
}

@Article{Rem:1981:APN,
  author =       "Martin Rem",
  title =        "Associons: a Program Notation with Tuples Instead of
                 Variables",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "251--262",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lindstrom:1981:RRB,
  author =       "Gary Lindstrom and Mary Lou Soffa",
  title =        "Referencing and Retention in Block-Structured
                 Coroutines",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "263--292",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barnden:1981:NCA,
  author =       "J. A. Barnden",
  title =        "Nonsequentiality and Concrete Activity Phases in
                 Discrete-Event Simulation Languages",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "293--317",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anderson:1981:LLC,
  author =       "S. O. Anderson and R. C. Backhouse",
  title =        "Locally Least-Cost Error Recovery in {Early}'s
                 Algorithm",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "3",
  pages =        "318--347",
  month =        jul,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Borning:1981:PLA,
  author =       "Alan Borning",
  title =        "The Programming Language Aspects of {ThingLab}, a
                 Constraint-Oriented Simulation Laboratory",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "353--387",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jazayeri:1981:SES,
  author =       "Medhi Jazayeri and Diane Pozefsky",
  title =        "Space-Efficient Storage Management in an Attribute
                 Grammar Evaluator",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "388--404",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Andrews:1981:SR,
  author =       "Gregory R. Andrews",
  title =        "Synchronizing Resources",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "405--430",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Apt:1981:TYH,
  author =       "Krzysztof R. Apt",
  title =        "Ten Years of {Hoare}'s Logic: a Survey --- {Part I}",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "431--483",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/prog.lang.theory.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Greif:1981:SSW,
  author =       "Irene Greif and Albert R. Meyer",
  title =        "Specifying the Semantics of while Programs: a Tutorial
                 and Critique of a Paper by {Hoare} and {Lauer}",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "484--507",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hansen:1981:CMI,
  author =       "Wilfred J. Hansen",
  title =        "A Cost Model for the Internal Organization of
                 {B$^+$}-Tree Nodes",
  journal =      j-TOPLAS,
  volume =       "3",
  number =       "4",
  pages =        "508--532",
  month =        oct,
  year =         "1981",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Feather:1982:SAP,
  author =       "Martin S. Feather",
  title =        "A System for Assisting Program Transformation",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "1--20",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Program transformation has been advocated as a
                 potentially appropriate methodology for program
                 development. The ability to transform large programs is
                 crucial to the practicality of such an approach. This
                 paper describes research directed towards applying one
                 particular transformation method to problems of
                 increasing scale. The method adopted is that developed
                 by Burstall and Darlington, and familiarity with their
                 work is assumed. The problems which arise when
                 attempting transformation of larger scale programs are
                 discussed, and an approach to overcoming them is
                 presented. Parts of the approach have been embodied in
                 a machine-based system which assists a user in
                 transforming his programs. The approach, and the use of
                 this system, are illustrated by presenting portions of
                 the transformation of a compiler for a ``toy''
                 language.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "program development; program transformation",
  sjb =          "Manual transformation method i.e. the program has to
                 be told where to do the transformations.",
  source =       "Dept. Library",
}

@Article{Tanenbaum:1982:UPO,
  author =       "Andrew S. Tanenbaum and Hans {van Staveren} and Johan
                 W. Stevenson",
  title =        "Using Peephole Optimization on Intermediate Code",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "21--36",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:58:22 1998",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remarks \cite{Pemberton:1983:TCT}.",
  abstract =     "Many portable compilers generate an intermediate code
                 that is subsequently translated into target machine's
                 assembly language. In this paper a stack-machine-based
                 intermediate code suitable for algebraic languages
                 (e.g., PASCAL, C, FORTRAN) and most byte-addressed
                 mini- and microcomputers is described. A table-driven
                 peephole optimizer that improves the intermediate code
                 is discussed in detail and compared with other local
                 optimization methods. Measurements show an improvement
                 of about 15 percent, depending on precise metrics
                 used.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract machine; intermediate code; peephole
                 optimizer",
  source =       "Dept. Library",
}

@Article{Misra:1982:TDD,
  author =       "Jayadev Misra and K. M. Chandy",
  title =        "Termination Detection of Diffusing Computations in
                 Communicating Sequential Processes",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "37--43",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this paper it is shown how the Dijkstra-Scholten
                 scheme for termination detection in a diffusing
                 computation can be adapted to detect termination or
                 deadlock in a network of communicating sequential
                 processes as defined by Hoare.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "diffusing computation; distributed systems; networks
                 of processes; termination detection",
  source =       "Dept. Library",
}

@Article{McGraw:1982:VLD,
  author =       "James R. McGraw",
  title =        "The {VAL} Language: Description and Analysis",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "44--82",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/Functional.bib; Parallel/par.dataflow.bib",
  abstract =     "VAL is a high-level, function-based language designed
                 for use on data flow computers. A data flow computer
                 has many small processors organized to cooperate in the
                 execution of a single computation. A computation is
                 represented by its data flow graph; each operator in a
                 graph is scheduled for execution on one of the
                 processors after all of its operands' values are known.
                 VAL promotes the identification of concurrency in
                 algorithms and simplifies the mapping into data flow
                 graphs. This paper presents a detailed introduction to
                 VAL and analyzes its usefulness for programming in a
                 highly concurrent environment. VAL provides {\em
                 implicit concurrency\/} (operations that can execute
                 simultaneously are evident without the need for any
                 explicit language notation). The language uses
                 function- and expression-based features that prohibit
                 all side effects, which simplifies translation to
                 graphs. The salient language features are described and
                 illustrated through examples taken from a complete VAL
                 program for adaptive quadrature. Analysis of the
                 language shows that VAL meets the critical needs for a
                 data flow environment. The language encourages
                 programmers to think in terms of general concurrency,
                 enhances readability (due to the absence of side
                 effects), and possesses a structure amenable
                 verification techniques. However, VAL is still
                 evolving. The language definition needs refining, and
                 more support tools for programmer use need to be
                 developed. Also, some new kinds of optimization
                 problems should be addressed.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "applicative languages; concurrent programming
                 structures; data-flow languages; design; functional;
                 languages",
  source =       "Dept. Library",
}

@Article{Hoffman:1982:PE,
  author =       "Christoph M. Hoffman and Michael J. O'Donnell",
  title =        "Programming with Equations",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "83--112",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Equations provide a convenient notation for defining
                 many computations, for example, for programming
                 language interpreters. This paper illustrates the
                 usefulness of equational programs, describes the
                 problems involved in implementing equational programs,
                 and investigates practical solutions to those problems.
                 The goal of the study is a system to automatically
                 transform a set of equations into an efficient program
                 which exactly implements the logical meaning of the
                 equations. This logical meaning may be defined in terms
                 of the traditional mathematical interpretation of
                 equations, without using advanced computing concepts.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "equations; interpreters; nonprocedural languages;
                 term-rewriting systems",
  sjb =          "Includes code for a 2-3 tree.",
}

@Article{Williams:1982:FNS,
  author =       "M. Howard Williams",
  title =        "A Flexible Notation for Syntactic Definitions",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "113--119",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 8 13:21:42 1984",
  bibsource =    "Compiler/bevan.bib; Compiler/compiler.bib;
                 https://www.math.utah.edu/pub/bibnet/authors/w/wirth-niklaus.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In view of the proliferation of notations for defining
                 the syntax of programming languages, it has been
                 suggested that a simple notation should be adopted as a
                 standard. However, any notation adopted as a standard
                 should also be as versatile as possible. For this
                 reason, a notation is presented here which is both
                 simple and versatile and which has additional benefits
                 when specifying the static semantic rules of a
                 language.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "BNF; syntax",
  sjb =          "Suggests some additions to Wirth's notation to capture
                 some commonly required constraints such as ``maximum
                 length of an identifier is $X$'', ``$X$ can be repeated
                 $Y$ times''. The ``simple and versatile'' notation is
                 just Wirth's EBNF augmented with affixes/attributes.
                 Ends with the following ``It is hoped that this paper
                 will not be viewed simply as a presentation of yet
                 another notation for syntactic definitions. The main
                 purpose of the paper has been to look closely at the
                 advantages of the notation proposed, and it is hoped
                 that in the future, before adopting any syntactic
                 notation, readers will give careful consideration to
                 the advantages of such a notation and avoid the
                 introduction of new notations or variations on existing
                 ones unless the advantages can be clearly spelled
                 out.''",
}

@Article{Ellis:1982:TCS,
  author =       "John R. Ellis",
  title =        "Technical Correspondence: On {Steensgaard-Madsen}'s
                 ``{A Statement-Oriented Approach to Data
                 Abstraction}''",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "120--122",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:08:12 1996",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See
                 \cite{Steensgaard-Madsen:1981:SOA,Steensgaard-Madsen:1982:TCS}",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  sjb =          "Points out that Madsen's ``new'' approach already
                 exists in languages like Smalltalk and Scheme.",
}

@Article{Steensgaard-Madsen:1982:TCS,
  author =       "J. Steensgaard-Madsen",
  title =        "Technical Correspondence: {Steensgaard-Madsen}'s
                 reply",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "1",
  pages =        "122--123",
  month =        jan,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See
                 \cite{Steensgaard-Madsen:1981:SOA,Ellis:1982:TCS}.",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  sjb =          "Admits ignorance of Scheme and Smalltalk, but doggedly
                 clings to the idea that his approach is new.",
}

@Article{Schneider:1982:SDP,
  author =       "Fred B. Schneider",
  title =        "Synchronization in Distributed Programs",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "125--148",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A technique for solving synchronization problems in
                 distributed programs is described. Use of this
                 technique in environments in which processes may fail
                 is discussed. The technique can be used to solve
                 synchronization problems directly, to implement new
                 synchronization mechanisms (which are presumably well
                 suite for use in distributed programs), and to
                 construct distributed versions of existing
                 synchronization mechanisms. use of the technique is
                 illustrated with implementations of distributed
                 semaphores and a conditional message-passing
                 facility.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "logical clocks",
  source =       "Dept. Library",
}

@Article{Holt:1982:ISS,
  author =       "Richard C. Holt and J. R. Cordy and David B. Wortman",
  title =        "An Introduction to {S/SL}: {Syntax\slash Semantic
                 Language}",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "149--178",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 18:36:33 1996",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "S/SL (Syntax/Semantic Language) is a language that was
                 developed for implementing compilers. A subset called
                 SL (Syntax Language) has the same recognition power as
                 do LR(k) parsers. Complete S/SL includes invocation of
                 semantic operations implemented in another language
                 such as PASCAL. S/SL implies a top-down programming
                 methodology. First, a data-free algorithm is developed
                 in S/SL. The algorithm invokes operations on ``semantic
                 mechanisms.'' A semantic mechanism is an abstract
                 object, specified, from the point of view of the S/SL,
                 only by the effect of operations upon the object.
                 Later, the mechanisms are implemented apart from the
                 S/SL program. The separation of the algorithm from the
                 data and the division of data into mechanisms reduce
                 the effort needed to understand and maintain the
                 resulting software. S/SL has been used to construct
                 compilers for SPECKLE (a PL/I subset), PT (a PASCAL
                 subset), Toronto EUCLID, and Concurrent EUCLID. It has
                 been used to implement scanners, parser, semantic
                 analyzers, and code generators. S/SL programs are
                 implemented by translating them into tables of
                 integers. A ``table walker'' program executes the S/SL
                 program by interpreting this table. The translation of
                 S/SL programs into tables is performed by a program
                 called the S/SL processor. This processor serves a
                 function analogous to that served by an LR(k) parser
                 generator. The implementation of S/SL is simple and
                 portable. It is available in a small subset of PASCAL
                 that can be easily transliterated into other high-level
                 languages.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design languages; LR(k)",
  source =       "Dept. Library",
}

@Article{Soisalon-Soininen:1982:IEE,
  author =       "Eljas Soisalon-Soininen",
  title =        "Inessential Error Entries and Their Use in {LR} Parser
                 Optimization",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "179--195",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{LaLonde:1984:TCC}.",
  abstract =     "The use of ``default reductions'' in implementing LR
                 parsers is considered in conjunction with the desire to
                 decrease the number of states of the parser by making
                 use of ``don't care'' (also called ``inessential'')
                 error entries. Default reduction are those which are
                 performed independently of the lookahead string when
                 other operations do not apply, and their use can lead
                 to substantial savings in space and time. Don't-care
                 error entries of an LR parser are those which are never
                 consulted, and thus they can be arbitrarily replaced by
                 nonerror entries in order to make a state compatible
                 with another one. Determining don't-care error entries
                 is most important in avoiding the growth of the sie of
                 the parser when eliminating reductions by single
                 productions, that is, productions for which the
                 right-hand side is a single symbol. The use of default
                 reductions diminishes don't-care entries. This effect
                 is analyzed by giving a necessary and sufficient
                 condition for an error entry to be don't care when
                 default reductions are used. As an application,
                 elimination of reductions by single productions in
                 conjunction with the use of default reductions is
                 considered.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "default reductions; don't-care error entries; LR(k);
                 single productions",
  source =       "Dept. Library",
}

@Article{Sharir:1982:SOC,
  author =       "Micha Sharir",
  title =        "Some Observations Concerning Formal Differentiation of
                 Set Theoretic Expressions",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "196--225",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wetherell:1982:EDV,
  author =       "C. S. Wetherell",
  title =        "Error Data Values in the Data-Flow Language {VAL}",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "226--238",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The data-flow architecture is intended to support
                 large scientific computations, and VAL is an algebraic,
                 procedural language for use on a data-flow computer.
                 VAL is Apt for numerical computations but requires an
                 error monitoring feature that can be used to diagnose
                 and correct errors arising during program execution.
                 Traditional monitoring methods (software traps and
                 condition codes) are inappropriate for VAL; instead VAL
                 includes a set of error data values and an algebra for
                 their manipulation. The error data values and their
                 algebra are described an assessed; the conclusion is
                 that error values provide a clean way for a high-level
                 language to handle numeric (and some other) errors.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "applicative languages; computer arithmetic; data-flow
                 architectures; data-flow languages; design; error
                 handling and recovery; languages",
  sjb =          "easy read",
  source =       "Dept. Library",
}

@Article{Fateman:1982:HLL,
  author =       "Richard J. Fateman",
  title =        "High-Level Language Implications of the Proposed
                 {IEEE} Floating-Point Standard",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "239--257",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/357162.357168",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 8 14:50:28 2007",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/bibnet/subjects/acc-stab-num-alg-2ed.bib;
                 https://www.math.utah.edu/pub/bibnet/subjects/acc-stab-num-alg.bib;
                 https://www.math.utah.edu/pub/tex/bib/fortran2.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "An IEEE Computer Society working group on
                 floating-point arithmetic has recommended a standard
                 for binary floating-point number formats, operations,
                 and semantics. This paper, which has evolved in part
                 during the deliberations of that committee, describes
                 the significance to languages and, in particular, to
                 FORTRAN and its variants, of various novel features of
                 the recommended standard.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "computer arithmetic; control structures; data types
                 and structures; error handling and recovery;
                 floating-point arithmetic; FORTRAN; run-time
                 environments",
  source =       "Dept. Library",
}

@Article{Martelli:1982:EUA,
  author =       "Alberto Martelli and Ugo Montanari",
  title =        "An Efficient Unification Algorithm",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "258--282",
  month =        feb,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/prolog.1.bib; Compiler/bevan.bib;
                 Compiler/Compiler.Lins.bib;
                 Compiler/prog.lang.theory.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/formal.hardware.verification.bib",
  abstract =     "The unification problem in first-order predicate
                 calculus is described in general terms as the solution
                 of a system of equations, and a nondeterministic
                 algorithm is given. A new unification algorithm,
                 characterized by having the acyclicity test efficiently
                 embedded into it, is derived from the nondeterministic
                 one, and a PASCAL implementation is given. A comparison
                 with other well-known unification algorithms shows that
                 the algorithm described here performs well in all
                 cases.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; complexity of proof procedures; languages;
                 logic; mechanical theorem proving; performance; prolog;
                 resolution; theory",
  source =       "Dept. Library",
}

@Article{Ashcroft:1982:RS,
  author =       "E. A. Ashcroft and W. W. Wadge",
  title =        "{{\bf R}}$_{\! \! \! \mbox {\raisebox {.5ex}{\tiny
                 /}}}$ for Semantics",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "283--294",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A constructive criticism of recent work in the
                 semantics of programming languages is offered. The
                 criticism is directed not so much at the techniques and
                 results obtained as at the use to which they are put.
                 The fact that denotational (or ``mathematical'')
                 semantics plays on the whole a passive
                 (``descriptive'') role, while operational semantics
                 plays on the whole an active (``prescriptive'') role,
                 is seen as the basic problem. It is suggested that
                 these roles be reversed.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "denotational semantics; operational semantics;
                 semantics; theory",
  sjb =          "Easy read. Note the format of the title is taken the
                 ACM TOPLAS bibliography maintained by
                 preston@cs.rice.edu",
  source =       "Dept. Library",
}

@Article{Arsac:1982:STR,
  author =       "J. Arsac and Y. Kodratoff",
  title =        "Some Techniques for Recursion Removal from Recursive
                 Functions",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "2",
  pages =        "295--322",
  month =        apr,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Three different techniques that can be used for
                 recursion removal are described: generalization of the
                 function definition, study of the computation traces of
                 the function, and nonprocedural languages. Despite the
                 existence of implemented versions of these techniques,
                 they are easy to use ``by hand'' and should therefore
                 be part of every programmers knowledge.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "computation trace; denotational semantics; operational
                 semantics; recursion removal; semantics; tail
                 recursion",
  sjb =          "Gets a bit heavy in places, but on the whole quite
                 readable.",
  source =       "Dept. Library",
}

@Article{Hennessy:1982:SDO,
  author =       "John L. Hennessy",
  title =        "Symbolic Debugging of Optimized Code",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "323--344",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 14:20:25 1996",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remark \cite{Copperman:1993:TCF}.",
  abstract =     "The long-standing conflict between code optimization
                 and symbolic debugging is examined. The effects of
                 local and global optimizations on the variables of a
                 program are categorized, and models for representing
                 the effect of optimizations are given. Algorithms use
                 these models to determine the subset of variables hose
                 values do not correspond to those in the original
                 program. Restoring these variables to their correct
                 values is investigated, and empirical results from the
                 application of these algorithms to local optimization
                 are also presented.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code generation optimization; debugging aids; directed
                 acyclic graphs; flow graphs; symbolic debugging",
  source =       "Dept. Library",
}

@Article{Sipala:1982:CSB,
  author =       "Paolo Sipala",
  title =        "Compact Storage of Binary Trees",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "345--361",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Broy:1982:CAA,
  author =       "Manfred Broy and Peter Pepper",
  title =        "Combining Algebraic and Algorithmic Reasoning: An
                 Approach to the {Schorr--Waite} Algorithm",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "362--381",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The basic idea of the Schorr--Waite graph-marking
                 algorithm can be precisely formulated, explained, and
                 verified in a completely applicative (functional)
                 programming style. Graphs are specified algebraically
                 as objects of an abstract data type. When formulating
                 recursive programs over such types, one can combine
                 algebraic and algorithmic reasoning: An applicative
                 depth-first-search algorithm is derived from a
                 mathematical specification by applying properties of
                 reflexive, transitive closures of relations. This
                 program is then transformed in several steps into a
                 final procedural version with the help of both
                 algebraic properties of graphs and algorithmic
                 properties reflected in the recursion structure of the
                 program.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract data types; algorithms; applicative
                 (functional) programming; languages; program
                 transformation; verification",
  source =       "Dept. Library",
}

@Article{Lamport:1982:BGP,
  author =       "Leslie Lamport and Robert Shostak and Marshall Pease",
  title =        "The {Byzantine} Generals Problem",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "382--401",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Oct 17 12:24:31 1998",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib; Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/ProbAlgs.bib",
  note =         "They proved that Byzantine agreement (the subject of
                 Section~\ref{sec-byzantine}) cannot be reached unless
                 fewer than one-third of the processes are faulty. This
                 result assumes that authentication, i.e., the crypting
                 of messages to make them unforgeable, is not used. With
                 unforgeable messages, they show that the problem is
                 solvable for any $ n \geq t > 0 $, where $n$ is the
                 total number of processes and $t$ is the number of
                 faulty processes.",
  abstract =     "Reliable computer systems must handle malfunctioning
                 components that give conflicting information to
                 different parts of the system. This situation can be
                 expressed abstractly in terms of a group of generals of
                 the Byzantine army camped with their troops around an
                 enemy city. Communicating only by messenger, the
                 generals must agree upon a common battle plan. However,
                 one or more of them may be traitors who will try and
                 confuse the others. The problem is to find an algorithm
                 to ensure that the loyal generals will reach agreement.
                 It is shown that, using only oral messages, this
                 problem is solvable if and only if more than two-thirds
                 of the generals are loyal; so a single traitor can
                 confound two loyal generals. With unforgeable written
                 messages, the problem is solvable for any number of
                 generals and possible traitors. Applications of the
                 solutions to reliable computer systems are then
                 discussed.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "fault tolerance; interactive consistency; network
                 communications; network operating systems;
                 reliability",
  source =       "Dept. Library",
}

@Article{Paige:1982:FDC,
  author =       "Robert Paige and Shaye Koenig",
  title =        "Finite Differencing of Computable Expressions",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "402--454",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Finite differencing is a program optimization method
                 that generalizes strength reduction, and provides an
                 efficient implementation for a host of program
                 transformations including ``iterator inversion.''
                 Finite differencing is formally specified in terms of
                 more basic transformations shown to preserve program
                 semantics. Estimates of the speedup that the technique
                 yields are given. A full illustrative example of the
                 algorithm is given.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; automatic programming; computations on
                 discrete structures; differentiable expression;
                 languages; optimization; program transformation; SETL;
                 theory; verification; very high-level languages",
  source =       "Dept. Library",
}

@Article{Owicki:1982:PLP,
  author =       "Susan Owicki and Leslie Lamport",
  title =        "Proving Liveness Properties of Concurrent Programs",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "455--495",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/nonmono.bib; Compiler/bevan.bib;
                 Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A liveness property asserts that program execution
                 eventually reaches some desirable state. While
                 termination has been studied extensively, many other
                 liveness properties are important for concurrent
                 programs. A formal proof method, based on temporal
                 logic, for deriving liveness properties is presented.
                 It allows a rigorous formulation of simple informal
                 arguments. How to reason with temporal logic and how to
                 use safety (invariance) properties in proving liveness
                 is shown. The method is illustrated using, first, a
                 simple programming language without synchronization
                 primitives, then one with semaphores. However, it is
                 applicable to any programming language.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrent programming; fairness; languages; liveness;
                 multiprocessing; program verification; proof of
                 correctness; semantics of programming languages;
                 synchronization; temporal logic; theory; verification",
  source =       "Dept. Library",
}

@Article{Wand:1982:DTC,
  author =       "Mitchell Wand",
  title =        "Deriving Target Code as a Representation of
                 Continuation Semantics",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "496--517",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Reynolds' technique for deriving interpreters is
                 extended to derive compilers from continuation
                 semantics. The technique starts by eliminating $
                 \lambda $-variables from the semantic equations through
                 the introduction of special-purpose combinators. The
                 semantics of a program phrase may be represented by a
                 term built from these combinators. Then associative and
                 distributive laws are used to simplify the terms. Last,
                 a machine is built to interpret the simplified terms as
                 the functions they represent. The combinators reappear
                 as the instructions of this machine. The technique is
                 illustrated with three examples.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code generation; combinators; compilers;
                 continuations; denotational semantics; lambda calculus;
                 semantics",
  sjb =          "excellent paper",
  source =       "Dept. Library",
}

@Article{Krogh:1982:AAP,
  author =       "Fred T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "518--521",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:36:09 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1982:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "3",
  pages =        "522--525",
  month =        jul,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Herlihy:1982:VTM,
  author =       "Maurice P. Herlihy and Barbara Liskov",
  title =        "A Value Transmission Method for Abstract Data Types",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "527--551",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 26 15:49:48 1988",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  abstract =     "Abstract data types have proved to be a useful
                 technique for structuring systems. In large systems it
                 is sometimes useful to have different regions of the
                 system use different representations for the abstract
                 data values. A technique is described for communicating
                 abstract values between such regions. The method was
                 developed for use in constructing distributed systems,
                 where the regions exist at different computers and the
                 values are communicated over a network. The method
                 defines a call-by-value semantics; it is also useful in
                 nondistributed systems wherever call by value is the
                 desired semantics. An important example of such a use
                 is a repository, such as a file system, for storing
                 long lived data.",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract data types; call by value; data translation;
                 design; distributed systems; input/output; languages;
                 long-term storage.; message communications; message
                 sending",
  sjb =          "For every type that is to be transmitted, need to
                 define encode $:: T \rightarrow XT$, decode $:: XT
                 \rightarrow T$, from these, the ``system'' generates
                 transmit $:: T\rightarrow T$ and transmit $:: XT
                 \rightarrow XT$, where $XT$ is the external
                 representation. As an example of how $XT$ may differ
                 from $T$, in the case of 2D coordinates, $T$ might be
                 cartesian whereas $XT$ may be a variant containing
                 either cartesian or polar. Note that it is up to the
                 user to decide what to do about sharing e.g. to
                 structured types having a pointer to a third.",
  source =       "Dept. Library",
}

@Article{Holt:1982:MIE,
  author =       "Richard C. Holt and David B. Wortman",
  title =        "A Model for Implementing {Euclid} Modules and
                 Prototypes",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "552--562",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The PASCAL-based programming language EUCLID was
                 designed for use in implementing verifiable systems
                 software. The design of EUCLID includes many novel
                 extensions, including a module mechanism and a
                 substantial generalization of the PASCAL type
                 mechanism. This paper presents an implementation model
                 for two of these extensions: modules and parameterized
                 type definitions (prototypes).",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract data types; data types and structures;
                 EUCLID; packages; run-time environments; systems
                 implementation language",
  sjb =          "Amongst other things discusses how to compile generics
                 e.g. macro vs. shared.",
  source =       "Dept. Library",
}

@Article{Griswold:1982:EEI,
  author =       "Ralph E. Griswold",
  title =        "The Evaluation of Expressions in {Icon}",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "563--584",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Expressions in the Icon programming language may be
                 {\em conditional}, possibly producing no result, or
                 they may be {\em generators}, possibly producing a
                 sequence of results. Generators, coupled with a goal
                 directed evaluation mechanism, provide a concise method
                 for expression many complex computations. This paper
                 describes the evaluation of expressions in Icon and
                 presents an Icon program that explicates the semantics
                 of expression evaluation. This program also provides an
                 executable ``formalism'' that can be used as a tool to
                 design and test changes and additions to the
                 language.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "control structures; Icon; interpreters; semantics",
  source =       "Dept. Library",
}

@Article{Gergeron:1982:SAS,
  author =       "J. Gergeron and A. Dubuque",
  title =        "A Structured {APL} System",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "585--600",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A structured APL system introducing several
                 interesting features is described. The APL group
                 concept has been considerably extended to yield a new
                 type of APL object called a segment. Segments
                 constitute the basic building blocks used to manage
                 memory and build up the workspace and the user's
                 library. The encapsulation capability provides a
                 unified scheme for handling variables, functions and
                 other APL objects, including files. A new structured
                 user library is proposed. The dynamic call of objects
                 during a terminal session links the user library to the
                 workspace. New types of variables are described along
                 with solutions to interesting problems based on them.",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "APL; segmentation; software libraries; workspace",
  source =       "Dept. Library",
}

@Article{Baker:1982:OPA,
  author =       "T. P. Baker",
  title =        "A One-Pass Algorithm for Overload Resolution in
                 {Ada}",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "601--614",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A simple method is presented for detecting ambiguities
                 and finding the correct interpretations of expressions
                 in the programming language Ada. Unlike previously
                 reported solutions to this problem, which require
                 multiple passes over a tree structure, the method
                 described here operates in one bottom-up pass, during
                 which a directed acyclic graph is produced. The
                 correctness of this approach is demonstrated by a brief
                 formal argument.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Ada; compilers; overloading; translators",
  source =       "Dept. Library",
}

@Article{DeRemer:1982:ECL,
  author =       "Frank DeRemer and Thomas Pennello",
  title =        "Efficient Computation of {LALR}(1) Look-Ahead Sets",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "615--649",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 4 17:32:11 1996",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Two relations that capture the essential structure of
                 the problem of computing LALR(1) look-ahead sets are
                 defined, an efficient algorithm is presented to compute
                 the sets in time linear in the size of the relations.
                 In particular, for a PASCAL grammar, the algorithm
                 performs fewer than 15 percent of the set unions
                 performed by the popular compiler-compiler YACC. When a
                 grammar is not LALR(1), the relations, represented
                 explicitly, provide for printing user-oriented error
                 messages that specifically indicate {\em how\/} the
                 look-ahead problem arose. In addition, certain loops in
                 the digraphs induced by these relations indicate that
                 the grammar is not LR($k$) for any $k$. Finally, on
                 oft-discovered and used but {\em incorrect\/}
                 look-ahead set algorithm is similarly based on two
                 other relations defined for the first time here. The
                 formal presentation of this algorithm should help
                 prevent its rediscovery.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Backus-Naur form; compiler generators; context-free
                 grammar; grammar debugging.; LALR(1); LR(k); parsing;
                 strongly connected component; syntax; translator
                 writing systems",
  source =       "Dept. Library",
}

@Article{Dewar:1982:TDG,
  author =       "Robert B. K. Dewar and Micha Sharir and Elia
                 Weixelbaum",
  title =        "Transformational Derivation of a Garbage Collection
                 Algorithm",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "650--667",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Transformational programming is a relatively new
                 programming technique intended to derive complex
                 algorithms automatically. Initially, a set of
                 transformational rules is described, and an initial
                 specification of the problem to be programmed is given.
                 The specification is written in a high-level language
                 in a fairly compact form possibly ignoring efficiency.
                 A number of versions, called transformations, are
                 created by successively applying the transformational
                 rules starting with the initial specification. As an
                 example of the application of this technique to a
                 fairly complex case, a transformational derivation of a
                 variant of known efficient garbage collection and
                 compaction algorithm from an initial very high-level
                 specification is given. Currently, the techniques are
                 still being developed, and therefore the
                 transformations are derived manually. However, most of
                 the transformations done are of a technical nature and
                 could eventually be automated.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; automatic programming; design; formal
                 differentiation; garbage collection; languages; loop
                 fusion; program transformation; strength reduction.;
                 transformational programming; very high level
                 languages; wide-spectrum languages",
  source =       "Dept. Library",
}

@Article{Boom:1982:WPL,
  author =       "H. J. Boom",
  title =        "A Weaker Precondition for Loops",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "668--677",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In his book, {\em A Discipline of Programming},
                 Dijkstra presents the skeleton for a programming
                 language and defines its semantics axiomatically using
                 predicate transformers. His language involves only
                 bounded nondeterminism. He shows that unbounded
                 nondeterminism is incompatible with his axioms and his
                 continuity principle, and he argues that this is no
                 drawback because unboundedly nondeterministic machines
                 cannot be built. This paper considers the question of
                 unbounded nondeterminism. A new predicate transformer
                 is derived to handle this. A proof is given that the
                 new transformer corresponds to operational semantics,
                 and an informal argument is given that unbounded
                 nondeterminism can be a useful programming concept even
                 in the absence of nondeterministic machines.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Ackermann's function; fair do loop; fair scheduling;
                 nondeterminism; predicate transformer; total
                 correctness; unbounded nondeterminism; weakest
                 precondition",
  source =       "Dept. Library",
}

@Article{Misra:1982:DGA,
  author =       "Jayadev Misra and K. M. Chandy",
  title =        "A Distributed Graph Algorithm: Knot Detection",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "678--686",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A {\em knot\/} is a directed graph is [sic] a useful
                 concept in deadlock detection. A distributed algorithm
                 for identifying a knot in a graph using a network of
                 processes is presented. The algorithm is based on the
                 work of Dijkstra and Scholten.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "distributed algorithms; distributed applications;
                 graph algorithms; knot; message communication; network
                 operating systems; network problems; sequencing and
                 scheduling",
  source =       "Dept. Library",
}

@Article{Mallgren:1982:FSG,
  author =       "William R. Mallgren",
  title =        "Formal Specification of Graphic Data Types",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "687--710",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Formal specification techniques and data abstractions
                 have seen little application to computer graphics. Many
                 of the objects and operations unique to graphics
                 programs can be handled conveniently by defining
                 special graphic data types. Not only do graphic data
                 types provide an attractive way to work with pictures,
                 but they also allow specification techniques for data
                 abstractions to be employed. Algebraic axioms, because
                 of their definitional nature, are especially well
                 suited to specifying the diversity of types useful in
                 graphics applications. In this paper, definitions are
                 given for some important concepts that appear in
                 graphics programs. Based on these definitions, some
                 illustrative graphic data types, called point, region,
                 geometric function, graphic transformation, and
                 tree-structured picture, are defined and specified
                 algebraically. A simple graphics language for line
                 drawings is created by embedding these new data types
                 in the language PASCAL. Using the specifications, an
                 outline of a correctness proof for a small programming
                 example is presented.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract data types; algebraic approaches to
                 semantics; correctness proofs; graphic data type;
                 languages; specification techniques; verification",
  sjb =          "readable",
  source =       "Dept. Library",
}

@Article{Thatcher:1982:DTS,
  author =       "J. W. Thatcher and E. G. Wagner and J. B. Wright",
  title =        "Data Type Specification: Parameterization and the
                 Power of Specification Techniques",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "711--732",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Our earlier work on abstract data types is extended by
                 the answers to a number of questions on the power and
                 limitations of algebraic specification techniques and
                 by a algebraic treatment of parameterized data types
                 like {\em set-of-(\ )\/} and {\em stacks-of(\ )}. The
                 ``hidden function'' problem (the need to include
                 operations in specifications which are wanted hidden
                 from the user) is investigated; the relative power of
                 conditional specifications and equational
                 specifications is investigated; and it is show that
                 parameterized specifications must contain ``side
                 conditions'' (e.g., that {\em finite-sets-of-d\/}
                 requires an equality predicate on $d$).",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract data types; algebraic approaches to
                 semantics; algebraic specification; semantics; type
                 structure",
  sjb =          "Looks dated now",
  source =       "Dept. Library",
}

@Article{Williams:1982:DAF,
  author =       "John H. Williams",
  title =        "On the Development of the Algebra of Functional
                 Programs",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "733--757",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/bevan.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The development of the algebraic approach to reasoning
                 about functional programs that was introduced by Backus
                 in his Turing Award Lecture is furthered. Precise
                 definitions for the foundations on which the algebra is
                 based are given, and some new expansion theorems that
                 broaden the class of functions for which this approach
                 is applicable are proved. In particular, the class of
                 ``overrun-tolerant'' forms, nonlinear forms that
                 include some of the familiar divide-and-conquer program
                 schemes, are defined; an expansion theorem for such
                 forms is proved; and that theorem is used to show how
                 to derive expansions for some programs defined by
                 nonlinear forms.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  checked =      "19940302",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algebraic approaches to semantics; applicative
                 (functional) programming; correctness proofs;
                 functional constructs; semantics; transformations",
  sjb =          "Looks dated now",
  source =       "Dept. Library",
}

@Article{Peterson:1982:UAC,
  author =       "Gary L. Peterson",
  title =        "An {$ O(n \log {n}) $} Unidirectional Algorithm for
                 the Circular Extrema Problem",
  journal =      j-TOPLAS,
  volume =       "4",
  number =       "4",
  pages =        "758--762",
  month =        oct,
  year =         "1982",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/ProbAlgs.bib",
  note =         "Peterson presents a deterministic distributed
                 algorithm for finding the largest of a set of $n$
                 uniquely numbered processes in a ring. The algorithm
                 requires $ O(n \log n)$ messages in the worst case, and
                 is unidirectional. The number of processes is not
                 initially known.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Merlin:1983:CSS,
  author =       "Philip Merlin and Gregor V. Bochmann",
  title =        "On the Construction of Submodule Specifications and
                 Communication Protocols",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "1--25",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Freudenberger:1983:ESO,
  author =       "Stefan M. Freudenberger and Jacob T. Schwartz and
                 Micha Sharir",
  title =        "Experience with the {SETL} Optimizer",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "26--45",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Peterson:1983:CRW,
  author =       "Gary L. Peterson",
  title =        "Concurrent Reading While Writing",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "46--55",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Peterson:1983:NSL,
  author =       "Gary L. Peterson",
  title =        "A New Solution to {Lamport}'s Concurrent Programming
                 Problem Using Small Shared Variables",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "56--65",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Database/Wiederhold.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "Immune to process failures and restarts.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gallager:1983:DAM,
  author =       "R. G. Gallager and P. A. Humblet and P. M. Spira",
  title =        "A Distributed Algorithm for Minimum-Weight Spanning
                 Trees",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "66--77",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kieburtz:1983:ARE,
  author =       "Richard B. Kieburtz and Abraham Silberschatz",
  title =        "Access-Right Expressions",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "78--96",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kamin:1983:FDT,
  author =       "Samuel Kamin",
  title =        "Final Data Types and Their Specification",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "97--121",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 11:07:03 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Henderson:1983:TCL,
  author =       "Peter B. Henderson",
  title =        "Technical Correspondence: On {LaLonde} and {des
                 Rivieres}' ``{Handling Operator Precedence in
                 Arithmetic Expressions with Tree Transformations}''",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "122--122",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{LaLonde:1981:HOP,LaLonde:1983:TCL}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{LaLonde:1983:TCL,
  author =       "Wilf R. LaLonde",
  title =        "Technical Correspondence: {LaLonde}'s Reply",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "1",
  pages =        "122--122",
  month =        jan,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{LaLonde:1981:HOP,Henderson:1983:TCL}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Reiss:1983:GCS,
  author =       "Steven P. Reiss",
  title =        "Generation of Compiler Symbol Processing Mechanisms
                 from Specifications",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "2",
  pages =        "127--163",
  month =        apr,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 28 16:03:28 1983",
  bibsource =    "Compiler/compiler.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "Compiler symbol processing has become complex as
                 programming languages have evolved. In this paper we
                 describe a comprehensive model of symbol processing,
                 and a system that uses this model to generate the
                 symbol processing portions of a compiler from simple
                 specifications. The model supports a variety of
                 entities with different types of names. It includes a
                 detailed view of scoping. It provides a simple picture
                 of the complex mapping from a source token to a
                 specific entity. The model is illustrated with examples
                 from Ada. The system is divided into two parts. The
                 first takes a nonprocedural description of the
                 semantics of symbols in the language and produces a
                 symbol table module for a compiler in that language.
                 The second supports a simple symbol processing language
                 that allows the easy connection of syntax and semantic
                 processing to the symbol module. [abstract]",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gottlieb:1983:BTE,
  author =       "Allan Gottlieb and Boris D. Lubachevsky and Larry
                 Rudolph",
  title =        "Basic Techniques for the Efficient Coordination of
                 Very Large Numbers of Cooperating Sequential
                 Processors",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "2",
  pages =        "164--189",
  month =        apr,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/Graefe.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "glr acm toplas",
}

@Article{Lamport:1983:SCP,
  author =       "Leslie Lamport",
  title =        "Specifying Concurrent Program Modules",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "2",
  pages =        "190--222",
  month =        apr,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Buckley:1983:EIG,
  author =       "G. N. Buckley and Abraham Silberschatz",
  title =        "An Effective Implementation for the Generalized
                 Input-Output Construct of {CSP}",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "2",
  pages =        "223--235",
  month =        apr,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/ProbAlgs.bib",
  note =         "They present a distributed algorithm for CSP output
                 guards based on priority ordering of processes. Their
                 algorithm has the property that two processes that can
                 communicate and do not establish communication with a
                 third process will communicate within a bounded time.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Maher:1983:API,
  author =       "B. Maher and D. H. Sleeman",
  title =        "Automatic Program Improvement: Variable Usage
                 Transformations",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "2",
  pages =        "236--264",
  month =        apr,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 28 16:27:08 1983",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "The design of the Leeds Transformation System is to
                 transform existing programs, written in a variety of
                 languages, into `tidier' programs. The total system was
                 conceived of as having three phases: syntactic
                 transformations, variable usage transformations, and
                 synthesizing features. Because programmers vary greatly
                 in what they consider to be a more acceptable form, we
                 have aimed to make the system as data driven as
                 possible. (That also enables us to deal with a variety
                 of programming languages.) The paper reviews the first
                 two phases, reports the second in some detail, and
                 illustrates the use of the system on an ALGOL 60
                 program. Redundant assignments, redundant variables,
                 and loop-invariant statements are discovered by means
                 of a novel approach which represents variable usage
                 within a program as a correspondence matrix. Potential
                 enhancements of the system are also discussed.
                 [abstract]",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cohen:1983:ERR,
  author =       "Norman H. Cohen",
  title =        "Eliminating Redundant Recursive Calls",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "265--299",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dekel:1983:PGP,
  author =       "Eliezer Dekel and Sartaj Sahni",
  title =        "Parallel Generation of Postfix and Tree Forms",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "300--317",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gazinger:1983:PSP,
  author =       "Harald Gazinger",
  title =        "Parameterized Specifications: Parameter Passing and
                 Implementation with Respect to Observability",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "318--354",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{DeMillo:1983:GEI,
  author =       "Richard A. DeMillo",
  title =        "{Guest Editor}'s Introduction",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "355--355",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:32:11 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hart:1983:TPC,
  author =       "Sergiu Hart and Micha Sharir and Amir Pnueli",
  title =        "Termination of Probabilistic Concurrent Program",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "356--380",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liskov:1983:GAL,
  author =       "Barbara Liskov and Robert Scheifler",
  title =        "Guardians and Actions: Linguistic Support for Robust,
                 Distributed Programs",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "381--404",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Nierstrasz.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "olit-oopl argus guardians transactions",
}

@Article{Lipton:1983:VLP,
  author =       "Richard J. Lipton and Jacobo Valdes and Gopalakrishnan
                 Vijayen and Stephen C. Notth and Robert Sedgewick",
  title =        "{VLSI} Layout as Programming",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "405--421",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/vlsi.bib",
  abstract =     "The first component of a VLSI design environment being
                 built at Princeton University is described. The general
                 theme of this effort is to make the design of VLSI
                 circuits as similar to programming as possible. The
                 attempt is to build tools that do for the VLSI circuit
                 designer what the best software tools do for the
                 implementor of large software systems.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "This paper describes ALI, a procedural language to
                 describe layouts. The main feature of ALI is that it
                 allows its user to design layouts at a conceptual level
                 at which neither sizes nor positions (absolute or
                 relative) of layout components may be specified. ALI is
                 similar to IDEAL in both design and implementation, in
                 that both use a strongly-typed variant of Pascal (or
                 C), both solve a set of linear inequalities to
                 determine the final positions of the elements, and both
                 support hierarchies through the use of procedures.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  owner =        "Rick Snodgrass",
}

@Article{Hennessy:1983:PCO,
  author =       "John L. Hennessy and Thomas Gross",
  title =        "Postpass Code Optimization of Pipeline Constraints",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "422--448",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Reps:1983:ICD,
  author =       "Thomas Reps and Tim Teitelbaum and Alan Demers",
  title =        "Incremental Context-Dependent Analysis for
                 Language-Based Editors",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "449--477",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Giegerich:1983:FFD,
  author =       "Robert Giegerich",
  title =        "A Formal Framework for the Derivation of
                 Machine-Specific Optimizers",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "478--498",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pemberton:1983:TCT,
  author =       "Steven Pemberton",
  title =        "Technical Correspondence: On {Tanenbaum}, {van
                 Staveren}, and {Stevenson}'s ``{Using Peephole
                 Optimization on Intermediate Code}''",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "499--499",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Tanenbaum:1982:UPO,Tanenbaum:1983:TCT}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tanenbaum:1983:TCT,
  author =       "Andrew S. Tanenbaum",
  title =        "Technical Correspondence: {Tanenbaum}'s Reply",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "499--500",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Tanenbaum:1982:UPO,Pemberton:1983:TCT}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moitra:1983:TCA,
  author =       "Abha Moitra",
  title =        "Technical Correspondence: On {Apt}, {Francez}, and {de
                 Roever}'s ``{A Proof System for Communicating
                 Sequential Processes}''",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "500--501",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Apt:1980:PSC}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Krogh:1983:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "502--505",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:36:05 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1983:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "3",
  pages =        "506--509",
  month =        jul,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Waters:1983:UFC,
  author =       "Richard C. Waters",
  title =        "User Format Control in a {Lisp} Prettyprinter",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "513--531",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cohen:1983:CCA,
  author =       "Jacques Cohen and Alexandru Nicolau",
  title =        "Comparison of Compacting Algorithms for Garbage
                 Collection",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "532--553",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sethi:1983:CFA,
  author =       "Ravi Sethi",
  title =        "Control Flow Aspects of Semantics-Directed Compiling",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "554--595",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/69575.357227",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/69575.357227",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jones:1983:TST,
  author =       "C. B. Jones",
  title =        "Tentative Steps Toward a Development Method for
                 Interfering Programs",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "596--619",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ossefort:1983:CPC,
  author =       "Marty Ossefort",
  title =        "Correctness Proofs of Communicating Processes: Three
                 Illustrative Examples from the Literature",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "620--640",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Weyuker:1983:ATD,
  author =       "Elaine J. Weyuker",
  title =        "Assessing Test Data Adequacy through Program
                 Inference",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "641--655",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sippu:1983:SEH,
  author =       "Seppo Sippu and Eljas Soisalon-Soininen",
  title =        "A Syntax-Error-Handling Technique and Its Experimental
                 Analysis",
  journal =      j-TOPLAS,
  volume =       "5",
  number =       "4",
  pages =        "656--679",
  month =        oct,
  year =         "1983",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Archer:1984:URR,
  author =       "James E. {Archer, Jr.} and Richard Conway and Fred B.
                 Schneider",
  title =        "User Recovery and Reversal in Interactive Systems",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "1--19",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cameron:1984:GBD,
  author =       "Robert D. Cameron and M. Robert Ito",
  title =        "Grammar-Based Definition of Metaprogramming Systems",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "20--54",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Colussi:1984:RES,
  author =       "L. Colussi",
  title =        "Recursion As an Effective Step in Program
                 Development",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "55--67",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Manna:1984:SCP,
  author =       "Zohar Manna and Pierre Wolper",
  title =        "Synthesis of Communicating Processes from Temporal
                 Logic Specifications",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "68--93",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/nonmono.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Nierstrasz.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "temporal-logic csp binder(csp)",
}

@Article{Constable:1984:TTP,
  author =       "Robert L. Constable and Daniel R. Zlatin",
  title =        "The Type Theory of {PL\slash CV3}",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "94--117",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 18:36:30 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kaufman:1984:TLR,
  author =       "Arie Kaufman",
  title =        "Tailored-List and Recombination-Delaying Buddy
                 Systems",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "1",
  pages =        "118--125",
  month =        jan,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Appelbe:1984:ECS,
  author =       "William F. Appelbe and A. P. Ravn",
  title =        "Encapsulation Constructs in Systems Programming
                 Languages",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "129--158",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Burton:1984:ACP,
  author =       "F. Warren Burton",
  title =        "{Annotations to Control Parallelism and Reduction
                 Order in the Distributed Evaluation of Functional
                 Programs}",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "159--174",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/Functional.bib; Parallel/Pfpbib.bib",
  abstract =     "When evaluating a functional program on a network of
                 processors, it is necessary to decide when parallelism
                 is desirable, which work may be transferred to another
                 processor, and in what form the work is to be
                 transferred. If the wrong decisions are made, a
                 parallel evaluation may require asymptotically more
                 time than a sequential evaluation, owing to
                 communication costs. The introduction of annotations to
                 give the programmer control over the above decisions is
                 proposed. The annotations and their effects are defined
                 in terms of the lambda calculus. Each application must
                 have one of three annotations. No other annotations are
                 required. Examples and possible extensions to this
                 work, including annotated combinators, are briefly
                 considered.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Annotations; Para-Functional Programming",
}

@Article{Hull:1984:CSP,
  author =       "M. Elizabeth C. Hull and R. M. McKeag",
  title =        "Communicating Sequential Processes for Centralized and
                 Distributed Operating System Design",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "175--191",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Backhouse:1984:GDF,
  author =       "Roland Backhouse",
  title =        "Global Data Flow Analysis Problems Arising in Locally
                 Least-Cost Error Recovery",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "192--214",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Reif:1984:RTS,
  author =       "John H. Reif and Paul G. Spirakis",
  title =        "Real-Time Synchronization of Interprocess
                 Communications",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "215--238",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/ProbAlgs.bib",
  note =         "They present probabilistic distributed algorithms for
                 the guard-scheduling problem
                 (Section~\ref{sec-guardscheduling}) that guarantee
                 real-time response. A preliminary version of this paper
                 appeared as ``Distributed Algorithms for Synchronizing
                 Interprocess Communication in Real Time,'' in {\em
                 Proc. 13th Ann. ACM Symp. on Theory of Computing},
                 1981.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Karp:1984:PFF,
  author =       "Richard Alan Karp",
  title =        "Proving Failure-Free Properties of Concurrent Systems
                 Using Temporal Logic",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "239--253",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lamport:1984:UTI,
  author =       "Leslie Lamport",
  title =        "Using Time Instead of Timeout for Fault-Tolerant
                 Distributed Systems",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "254--280",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lamport:1984:HLC,
  author =       "Leslie Lamport and Fred B. Schneider",
  title =        "The ``{Hoare} Logic'' of {CSP}, and All That",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "2",
  pages =        "281--296",
  month =        apr,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Budd:1984:ACV,
  author =       "Timothy A. Budd",
  title =        "An {APL} Compiler for a Vector Processor",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "297--313",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hobson:1984:DEE,
  author =       "Richard F. Hobson",
  title =        "A Directly Executable Encoding for {APL}",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "314--332",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ben-Ari:1984:AFG,
  author =       "Mordechai Ben-Ari",
  title =        "Algorithms for On-the-fly Garbage Collection",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "333--344",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Katayama:1984:TAG,
  author =       "Takuya Katayama",
  title =        "Translation of Attribute Grammars into Procedures",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "345--369",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Apt:1984:MDT,
  author =       "Krzysztof R. Apt and Nissem Francez",
  title =        "Modeling the Distributed Termination Convention of
                 {CSP}",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "370--379",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Korach:1984:DAF,
  author =       "E. Korach and D. Rotem and N. Santoro",
  title =        "Distributed Algorithms for Finding Centers and Medians
                 in Networks",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "380--401",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Schlichting:1984:UMP,
  author =       "Richard D. Schlichting and Fred B. Schneider",
  title =        "Using Message Passing for Distributed Programming:
                 Proof Rules and Disciplines",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "402--431",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{LaLonde:1984:TCC,
  author =       "Wilf R. LaLonde",
  title =        "Technical Correspondence: Comments on
                 {Soisalon-Soininen}'s ``{Inessential Error Entries and
                 Their Use in LR Parser Optimization}''",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "432--439",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Soisalon-Soininen:1982:IEE}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Krogh:1984:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "440--443",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:27:37 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1984:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "3",
  pages =        "444--447",
  month =        jul,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:28:08 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Winner:1984:UO,
  author =       "Robert I. Winner",
  title =        "Unassigned Objects",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "449--467",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Turini:1984:MLO,
  author =       "Franco Turini",
  title =        "{Magma2}: a Language Oriented toward Experiments in
                 Control",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "468--486",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bird:1984:PAS,
  author =       "R. S. Bird",
  title =        "The Promotion and Accumulation Strategies in
                 Transformational Programming",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "487--504",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See addendum \cite{Bird:1985:APA}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Davidson:1984:CST,
  author =       "Jack W. Davidson and Christopher W. Fraser",
  title =        "Code Selection through Object Code Optimization",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "505--526",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Nov 20 15:31:51 1984",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This paper shows how thorough object code optimization
                 has simplified a compiler and made it easy to retarget.
                 The code generator forgoes case analysis and emits
                 naive code that is improved by a retargetable object
                 code optimizer. With this technique, cross-compilers
                 emit code comparable to host-specific compilers",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code generation; compilation; optimization; peephole
                 optimization; portability",
}

@Article{Ramanath:1984:JML,
  author =       "M. V. S. Ramanath and Marvin Solomon",
  title =        "Jump Minimization in Linear Time",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "527--545",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Nov 20 15:35:55 1984",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Unlike other instructions, which compute or test
                 values, unconditional branch instructions do no useful
                 work. Rather, they are artifacts of the translation
                 from a flow graph to the linear form of conventional
                 machine language. Careful ordering of the basic blocks
                 of a program can decrease the number of branches
                 required by allowing a basic block to `fall through' to
                 a successor. It is shown that although the general
                 problem of minimizing the number of branches is
                 NP-complete, an efficient algorithm is possible for
                 `structured' programs --- those written without goto
                 statements. More specifically, an algorithm is
                 presented that produces an optimal odering of the basic
                 blocks of any program that uses only the control
                 structures if-then-else, loop, and exit. The running
                 time of the algorithm is proportional to the length of
                 the program, provided the number of loops exited by any
                 exit statement can be bounded by a constant.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code generation; code reordering; goto statements;
                 program optimization; unconditional branches",
}

@Article{Dencker:1984:OPT,
  author =       "Peter Dencker and Karl {D{\"u}rre} and Johannes
                 Heuft",
  title =        "Optimization of Parser Tables for Portable Compilers",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "546--572",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 7 11:53:52 1985",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/graph.coloring.bib",
  abstract =     "Six methods for parser table compression are compared.
                 The investigations are focused on four methods that
                 allow the access of table entries with a constant
                 number of index operations. The advantage of these
                 methods is that the access to the compressed tables can
                 be programmed efficiently in portable high-level
                 languages like Pascal or FORTRAN. The results are
                 related to two simple methods based on list searching.
                 Experimental results on eleven different grammers show
                 that, on the average, a method based on graph coloring
                 turns our best.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Graph coloring; sparse matrices; table compression",
}

@Article{Minsky:1984:SLC,
  author =       "Naftaly H. Minsky",
  title =        "Selective and Locally Controlled Transport of
                 Privileges",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "573--602",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Georgeff:1984:TRS,
  author =       "Michael Georgeff",
  title =        "Transformations and Reduction Strategies for Typed
                 Lambda Expressions",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "603--631",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remark \cite{Nielson:1986:TCC}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chandy:1984:DPP,
  author =       "K. M. Chandy and Jayadev Misra",
  title =        "The Drinking Philosopher's Problem",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "632--646",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 7 12:01:54 1985",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/os.bib; Os/os.bib",
  abstract =     "The problem of resolving conflicts between processes
                 in distributed systems is of practical importance. A
                 conflict between a set of processes must be resolved in
                 favor of some (usually one) process and against the
                 others: a favored process must have some property that
                 distinguishes it from others. To guarantee fairness,
                 the distinguishing property must be such that the
                 process selected for favorable treatment is not always
                 the same. A distributed implementation of an acyclic
                 precedence graph, in which the depth of a process (the
                 longest chain of predecessors) is a distinguishing
                 property, is presented. A simple conflict resolution
                 rule coupled with the acyclic graph ensures fair
                 resolution of all conflicts. To make the problem
                 concrete, two paradigms are presented: the well-known
                 distributed dining philosophers problem and a
                 generalization of it, the distributed drinking
                 philosophers problem.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Asymmetry; dining philosophers problem",
}

@Article{Soundararajan:1984:ASC,
  author =       "N. Soundararajan",
  title =        "Axiomatic Semantics of Communicating Sequential
                 Processes",
  journal =      j-TOPLAS,
  volume =       "6",
  number =       "4",
  pages =        "647--662",
  month =        oct,
  year =         "1984",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barstow:1985:CTD,
  author =       "David Barstow",
  title =        "On Convergence Toward a Database of Program
                 Transformations",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "1--9",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2364.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; measurement",
  subject =      "{\bf I.2.4}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Knowledge Representation Formalisms and
                 Methods. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.1.2}: Software, PROGRAMMING
                 TECHNIQUES, Automatic Programming. {\bf E.1}: Data,
                 DATA STRUCTURES, Graphs. {\bf I.2.4}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Knowledge
                 Representation Formalisms and Methods, PECOS.",
}

@Article{Zave:1985:DAF,
  author =       "Pamela Zave",
  title =        "A Distributed Alternative to Finite-State-Machine
                 Specifications",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "10--36",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2365.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Tools. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Bergeretti:1985:IFD,
  author =       "Jean-Fran{\c{c}}ois Bergeretti and Bernard A.
                 {Carr{\'e}}",
  title =        "Information-Flow and Data-Flow Analysis of
                 while-Programs",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "37--61",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2366.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "documentation; languages; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques. {\bf D.2.5}:
                 Software, SOFTWARE ENGINEERING, Testing and Debugging.
                 {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.4}: Software,
                 SOFTWARE ENGINEERING, Program Verification, Assertion
                 checkers.",
}

@Article{Fuchs:1985:OPF,
  author =       "David R. Fuchs and Donald E. Knuth",
  title =        "Optimal Prepaging and Font Caching",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "62--79",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 6 11:45:48 1985",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Graphics/graphics.1.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2367.html",
  abstract =     "An efficient algorithm for communicating letter-shape
                 information from a high-speed computer with a large
                 memory to a typesetting device that has a limited
                 memory is presented. The encoding is optimum in the
                 sense that the total time for typesetting is minimized,
                 using a model that generalizes well-known ``demand
                 paging'' strategies to the case where changes to the
                 cache are allowed before the associated information is
                 actually needed. Extensive empirical data show that
                 good results are obtained even when difficult technical
                 material is being typeset on a machine that can store
                 information concerning only 100 characters. The methods
                 of this paper are also applicable to other hardware and
                 software caching applications with restricted
                 lookahead.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; measurement; performance; theory",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Allocation/deallocation strategies. {\bf
                 D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Secondary storage. {\bf D.4.2}: Software,
                 OPERATING SYSTEMS, Storage Management, Virtual memory.
                 {\bf E.2}: Data, DATA STORAGE REPRESENTATIONS, Linked
                 representations. {\bf I.7.2}: Computing Methodologies,
                 TEXT PROCESSING, Document Preparation,
                 Photocomposition/typesetting.",
}

@Article{Gelernter:1985:GCL,
  author =       "David Gelernter",
  title =        "Generative Communication in {Linda}",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "80--112",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2433.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Linda. {\bf C.2.1}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS, Network
                 Architecture and Design, Network communications. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Concurrent
                 programming structures. {\bf D.4.4}: Software,
                 OPERATING SYSTEMS, Communications Management, Message
                 sending. {\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems, Distributed applications. {\bf
                 D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Distributed memories.",
}

@Article{Bates:1985:PP,
  author =       "Joseph L. Bates and Robert L. Constable",
  title =        "Proofs as Programs",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "113--136",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2528.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; theory; verification",
  subject =      "{\bf D.1.2}: Software, PROGRAMMING TECHNIQUES,
                 Automatic Programming. {\bf I.2.3}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving. {\bf F.3.1}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Specifying and
                 Verifying and Reasoning about Programs. {\bf I.2.2}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Automatic Programming. {\bf D.1.2}: Software,
                 PROGRAMMING TECHNIQUES, Automatic Programming, PRL.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification.",
}

@Article{Dunlop:1985:GSU,
  author =       "Douglas D. Dunlop and Victor R. Basili",
  title =        "Generalizing Specifications for Uniformly Implemented
                 Loops",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "137--158",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2708.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Specification techniques. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Assertion checkers. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness proofs.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Validation.",
}

@Article{Park:1985:NAL,
  author =       "Joseph C. H. Park and K. M. Choe and C. H. Chang",
  title =        "A New Analysis of {LALR} Formalisms",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "159--175",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 6 12:00:21 1985",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/2527.html",
  abstract =     "The traditional LALR analysis is reexamined using a
                 new operator and an associated graph. An improved
                 method that allows factoring out a crucial part of the
                 computation for defining states of LR(0) canonical
                 collection and for computing LALR(1) lookahead sets is
                 presented. This factorization leads to significantly
                 improved algorithms with respect to execution time as
                 well as storage requirements. Experimental results
                 including comparison with other known methods are
                 presented.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; LALR(1) lookahead sets;
                 LALR(k) grammar; languages; parser generating system;
                 performance; theory; verification",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Translator
                 writing systems and compiler generators. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Syntax. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Parsing.",
}

@Article{Wall:1985:TCN,
  author =       "D. Wall and A. Srivastava and F. Templin",
  title =        "Technical Correspondence: a Note on {Hennessy}'s
                 ``{Symbolic Debugging of Optimized Code}''",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "1",
  pages =        "176--181",
  month =        jan,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 6 12:03:08 1985",
  bibsource =    "Compiler/compiler.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/215005.html",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; performance; reliability",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Symbolic execution. {\bf D.2.3}:
                 Software, SOFTWARE ENGINEERING, Coding. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Heering:1985:TMP,
  author =       "Jan Heering and Paul Klint",
  title =        "Towards Monolingual Programming Environments",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "183--213",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 21 13:40:48 1985",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3321.html",
  abstract =     "Most programming environments are much too complex.
                 One way of simplifying them is to reduce the number of
                 mode-dependent languages the user has to be familiar
                 with. As a first step towards this end, the feasibility
                 of unified command/programming/debugging languages, and
                 the concepts on which such languages have to be based,
                 are investigated. The unification process is
                 accomplished in two phases. First, a unified
                 command/programming framework is defined and, second,
                 this framework is extended by adding an integrated
                 debugging capability to it. Strict rules are laid down
                 by which to judge language concepts presenting
                 themselves as candidates for inclusion in the framework
                 during each phase. On the basis of these rules many of
                 the language design questions that have hitherto been
                 resolved this way or that, depending on the taste of
                 the designer, lose their vagueness and can be decided
                 in an unambiguous manner.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "debugging language; design; event association;
                 language design; language integration; languages;
                 monolingual system; side-effect recovery; type
                 checking",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.4.7}: Software,
                 OPERATING SYSTEMS, Organization and Design. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.4.9}: Software, OPERATING SYSTEMS, Systems
                 Programs and Utilities. {\bf D.2.5}: Software, SOFTWARE
                 ENGINEERING, Testing and Debugging. {\bf D.4.9}:
                 Software, OPERATING SYSTEMS, Systems Programs and
                 Utilities, Command and control languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Smalltalk-80. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 INTERLISP.",
}

@Article{Yemini:1985:MVE,
  author =       "Shaula Yemini and Daniel M. Berry",
  title =        "A Modular Verifiable Exception-Handling Mechanism",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "214--243",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3320.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; reliability; security;
                 verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.2.5}: Software, SOFTWARE ENGINEERING, Testing and
                 Debugging, Error handling and recovery. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques,
                 Modules and interfaces. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Abstract data types. {\bf D.2.4}: Software,
                 SOFTWARE ENGINEERING, Program Verification. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, ALGOL-68. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Modules, packages.",
}

@Article{Weihl:1985:IRA,
  author =       "William Weihl and Barbara Liskov",
  title =        "Implementation of Resilient, Atomic Data Types",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "244--269",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/obscure.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3319.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; reliability",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Abstract data types. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Modules, packages. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, ARGUS.",
}

@Article{Milne:1985:CRC,
  author =       "George J. Milne",
  title =        "{CIRCAL} and the representation of communication,
                 concurrency, and time",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "270--298",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/Discrete.event.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3322.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, CIRCAL. {\bf
                 F.1.2}: Theory of Computation, COMPUTATION BY ABSTRACT
                 DEVICES, Modes of Computation, Parallelism and
                 concurrency. {\bf F.1.2}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Modes of Computation,
                 Alternation and nondeterminism. {\bf B.7.2}: Hardware,
                 INTEGRATED CIRCUITS, Design Aids, Verification. {\bf
                 C.2.3}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Operations.
                 {\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic, Lambda calculus and related
                 systems. {\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages.",
}

@Article{Schmidt:1985:DGV,
  author =       "David A. Schmidt",
  title =        "Detecting Global Variables in Denotational
                 Specifications",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "299--310",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3323.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.4.1}: Theory
                 of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Lambda calculus and
                 related systems. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.",
}

@Article{Pingali:1985:EDD,
  author =       "Keshav Pingali and Arvind",
  title =        "Efficient Demand-Driven Evaluation. Part 1",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "311--333",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3480.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf F.3.3}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs.",
}

@Article{Gini:1985:DWM,
  author =       "Giuseppina C. Gini and Maria L. Gini",
  title =        "Dealing with World-Model-Based Programs",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "334--347",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3479.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation; languages",
  subject =      "{\bf I.2.9}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Robotics. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf I.2.5}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Programming Languages and Software. {\bf J.6}: Computer
                 Applications, COMPUTER-AIDED ENGINEERING. {\bf I.2.9}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Robotics, POINTY.",
}

@Article{Bar-On:1985:OPG,
  author =       "Ilan Bar-On and Uzi Vishkin",
  title =        "Optimal Parallel Generation of a Computation Tree
                 Form",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "2",
  pages =        "348--357",
  month =        apr,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3478.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf F.2.2}: Theory of Computation, ANALYSIS OF
                 ALGORITHMS AND PROBLEM COMPLEXITY, Nonnumerical
                 Algorithms and Problems, Computations on discrete
                 structures. {\bf F.1.2}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Modes of Computation,
                 Parallelism and concurrency. {\bf G.2.2}: Mathematics
                 of Computing, DISCRETE MATHEMATICS, Graph Theory, Graph
                 algorithms. {\bf E.1}: Data, DATA STRUCTURES, Trees.",
}

@Article{Nielson:1985:PTD,
  author =       "Flemming Nielson",
  title =        "Program Transformations in a Denotational Setting",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "359--379",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3917.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 F.3.2}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Avrunin:1985:DAD,
  author =       "George S. Avrunin and Jack C. Wileden",
  title =        "Describing and Analyzing Distributed Software System
                 Designs",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "380--403",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3989.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Design languages. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification.
                 {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, DYMOL. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Jefferson:1985:VT,
  author =       "David R. Jefferson",
  title =        "Virtual Time",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "404--425",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Sep 30 16:35:18 1985",
  bibsource =    "Database/time.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3988.html",
  abstract =     "Virtual time a new paradigm for organizing and
                 synchronizing distributed systems which can be applied
                 to such problems as distributed discrete event
                 simulation and distributed database concurrency
                 control. Virtual time provides a flexible abstraction
                 of real time in much the same way that virtual memory
                 provides an abstraction of real memory. It is
                 implemented using the Time Warp mechanism, a
                 synchronization protocol distinguished by its reliance
                 on lookahead-rollback, and by its implementation of
                 rollback via antimessages.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency control; design; performance; reliability;
                 simulation; Time Warp",
  subject =      "{\bf D.4.7}: Software, OPERATING SYSTEMS, Organization
                 and Design, Distributed systems. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Synchronization.
                 {\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf F.1.2}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Modes of
                 Computation, Parallelism and concurrency.",
}

@Article{Donahue:1985:DTV,
  author =       "James Donahue and Alan Demers",
  title =        "Data Types Are Values",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "426--445",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 13 17:16:20 MDT 1994",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/sigplan.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3987.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  review =       "ACM CR 8604-0326",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 RUSSELL.",
}

@Article{Dershowitz:1985:PAI,
  author =       "Nachum Dershowitz",
  title =        "Program Abstraction and Instantiation",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "446--477",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/3986.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Structured programming. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Correctness proofs. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.1.2}:
                 Software, PROGRAMMING TECHNIQUES, Automatic
                 Programming. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Assertions. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Invariants. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Software
                 libraries.",
}

@Article{Richter:1985:NSE,
  author =       "Helmut Richter",
  title =        "Noncorrecting Syntax Error Recovery",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "478--489",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4019.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; Futures; languages; Lisp; performance; theory;
                 verification",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.2.5}:
                 Software, SOFTWARE ENGINEERING, Testing and Debugging,
                 Error handling and recovery. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Syntax.",
}

@Article{Bird:1985:APA,
  author =       "R. S. Bird",
  title =        "Addendum: ``{The Promotion and Accumulation Strategies
                 in Transformational Programming}''",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "490--492",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Bird:1984:PAS}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Krogh:1985:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "493--496",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:35:53 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1985:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "3",
  pages =        "497--500",
  month =        jul,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:36:44 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Halstead:1985:MLC,
  author =       "Robert H. {Halstead, Jr.}",
  title =        "{Multilisp: A Language for Concurrent Symbolic
                 Computation}",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "501--538",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Parallel/Pfpbib.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4478.html",
  abstract =     "Multilisp is a version of the Lisp dialect Scheme
                 extended with constructs for parallel execution. Like
                 Scheme, Multilisp is oriented toward symbolic
                 computation. Unlike some parallel programming
                 languages, Multilisp incorporates constructs for
                 causing side effects and for explicitly introducing
                 parallelism. The potential complexity of dealing with
                 side effects in a parallel context is mitigated by the
                 nature of the parallelism constructs and by support for
                 abstract data types: a recommended Multilisp
                 programming style is presented which, if followed,
                 should lead to highly parallel, easily understandable
                 programs. Multilisp is being implemented on the 32
                 processor {\em Concert\/} multiprocessor; however, it
                 is ultimately intended for use on larger
                 multiprocessors. The current implementation, called
                 {\em Concert Multilisp}, is complete enough to run the
                 Multilisp compiler itself and has been run on Concert
                 prototypes including up to eight processors. Concert
                 Multilisp uses novel techniques for task scheduling and
                 garbage collection. The task scheduler helps control
                 excessive resource utilization by means of an unfair
                 scheduling policy; the garbage collector uses a
                 multiprocessor algorithm based on the incremental
                 garbage collector of Baker.",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, MULTILISP. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf C.1.2}: Computer Systems Organization,
                 PROCESSOR ARCHITECTURES, Multiple Data Stream
                 Architectures (Multiprocessors),
                 Multiple-instruction-stream, multiple-data-stream
                 processors (MIMD). {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, LISP. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, SCHEME.",
}

@Article{Atkinson:1985:PPD,
  author =       "Malcolm P. Atkinson and Ronald Morrison",
  title =        "Procedures as Persistent Data Objects",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "539--559",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 13 17:16:20 MDT 1994",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/sigplan.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4477.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  review =       "ACM CR 8607-0603",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Procedures, functions, and
                 subroutines. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Abstract
                 data types. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques.",
}

@Article{Ganapathi:1985:AGD,
  author =       "Mahadevan Ganapathi and Charles N. Fischer",
  title =        "Affix Grammar Driven Code Generation",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "560--599",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 09:17:25 1996",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/sigplan.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4486.html",
  abstract =     "Affix grammars are used to describe the instruction
                 set of a target architecture for purposes of compiler
                 code generation. A code generator is obtained
                 automatically for a compiler using attributed parsing
                 techniques. A compiler built on this model can
                 automatically perform most popular machine-dependent
                 optimizations, including peephole optimizations. Code
                 generators based on this model demonstrate
                 retargetability for the VAX1-11, iAPX2-86, Z-80003,
                 PDP4-11, MC-68000, NS32032, FOM, and IBM-370
                 architectures.",
  acknowledgement = ack-pb # " and " # ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; Code generation; code optimization;
                 code-generator-generator; compiler compiler; design;
                 intermediate representation; languages; machine
                 description; machine-dependent optimization",
  owner =        "manning",
  review =       "ACM CR 8607-0604",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Translator writing systems and
                 compiler generators.",
}

@Article{Nix:1985:EE,
  author =       "Robert P. Nix",
  title =        "Editing by Example",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "600--621",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4476.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; theory",
  subject =      "{\bf I.7.1}: Computing Methodologies, TEXT PROCESSING,
                 Text Editing. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 synthesis. {\bf H.4.1}: Information Systems,
                 INFORMATION SYSTEMS APPLICATIONS, Office Automation,
                 Word processing. {\bf I.5.4}: Computing Methodologies,
                 PATTERN RECOGNITION, Applications, Text processing.
                 {\bf I.5.5}: Computing Methodologies, PATTERN
                 RECOGNITION, Implementation, Interactive systems. {\bf
                 I.7.1}: Computing Methodologies, TEXT PROCESSING, Text
                 Editing, Languages.",
}

@Article{Francez:1985:SIC,
  author =       "Nissim Francez and Shaula A. Yemini",
  title =        "Symmetric Intertask Communication",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "622--636",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4475.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.1.3}: Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Concurrency. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Synchronization. {\bf D.4.4}:
                 Software, OPERATING SYSTEMS, Communications Management.
                 {\bf F.3.3}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs.",
}

@Article{Boehm:1985:SEA,
  author =       "Hans-Juergen Boehm",
  title =        "Side Effects and Aliasing Can Have Simple Axiomatic
                 Descriptions",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "637--655",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4474.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Logics of programs. {\bf F.3.1}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Specifying and
                 Verifying and Reasoning about Programs, Mechanical
                 verification. {\bf F.3.3}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages.",
}

@Article{deBruin:1985:DSD,
  author =       "Arie de Bruin and Wim {B{\"o}hm}",
  title =        "The Denotational Semantics of Dynamic Networks of
                 Processes",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "656--679",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Oct 31 06:38:00 2003",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/4473.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Concurrent programming structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Coroutines. {\bf F.3.2}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Denotational
                 semantics. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, DNP.",
}

@Article{Cohen:1985:NCE,
  author =       "Norman H. Cohen",
  title =        "A note on {Cohen}'s {``Eliminating Redundant Recursive
                 Calls''}",
  journal =      j-TOPLAS,
  volume =       "7",
  number =       "4",
  pages =        "680--685",
  month =        oct,
  year =         "1985",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jun 1 08:35:36 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/215006.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.1.2}: Software, PROGRAMMING
                 TECHNIQUES, Automatic Programming. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Procedures, functions, and subroutines.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Program and recursion schemes.
                 {\bf G.2.2}: Mathematics of Computing, DISCRETE
                 MATHEMATICS, Graph Theory, Graph algorithms. {\bf
                 G.2.2}: Mathematics of Computing, DISCRETE MATHEMATICS,
                 Graph Theory, Trees.",
}

@Article{Clark:1986:PPP,
  author =       "Keith Clark and Steve Gregory",
  title =        "{Parlog}: parallel programming in logic",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "1--49",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5390.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, PARLOG. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative languages. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Prolog. {\bf I.2.3}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving, Logic programming.",
}

@Article{Leeman:1986:FAU,
  author =       "George B. {Leeman, Jr.}",
  title =        "A Formal Approach to Undo Operations in Programming
                 Languages",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "50--87",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5005.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; human factors; languages",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Error handling and recovery. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Procedures, functions, and subroutines.
                 {\bf D.4.5}: Software, OPERATING SYSTEMS, Reliability,
                 Checkpoint/restart. {\bf H.2.1}: Information Systems,
                 DATABASE MANAGEMENT, Logical Design, Data models. {\bf
                 H.2.7}: Information Systems, DATABASE MANAGEMENT,
                 Database Administration, Logging and recovery. {\bf
                 I.2.8}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Problem Solving, Control Methods, and
                 Search, Backtracking.",
}

@Article{Keller:1986:AC,
  author =       "Robert M. Keller and M. Ronan Sleep",
  title =        "Applicative Caching",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "88--108",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5004.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation; languages; measurement;
                 performance",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 E.2}: Data, DATA STORAGE REPRESENTATIONS. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors.",
}

@Article{Pingali:1986:EDD,
  author =       "Keshav Pingali and Arvind",
  title =        "Efficient Demand-Driven Evaluation. Part 2",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "109--139",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In Part 1 of this paper [5], we presented a scheme
                 whereby a compiler could propagate demands through
                 programs in a powerful stream language L. A data-driven
                 evaluation of the transformed program performed exactly
                 the same computation as a demand-driven evaluation of
                 the original program. In this paper we explore a
                 different transformation, which trades the complexity
                 of demand propagation for a {\em bounded\/} amount of
                 extra computation on some data lines.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "Categories and Subject Descriptors: Software -
                 Programming Techniques - Applicative (Functional)
                 Programming (D.1.1); Software - Programming Techniques
                 - Concurrent Programming (D.1.3); Software -
                 Programming Languages - Formal Definitions and Theory
                 (D.3.1): Semantics ; Theory of Computation - Logics and
                 Meanings of Programs - Semantics of Programming
                 Languages (F.3.2); Software - Programming Languages -
                 Processors (D.3.4); Theory of Computation - Logics and
                 Meanings of Programs - Studies of Program Constructs
                 (F.3.3); Software - Programming Languages - Language
                 Classifications (D.3.2); Software - Programming
                 Languages - Language Classifications (D.3.2): Data-flow
                 languages ; Software - Programming Languages -
                 Processors (D.3.4): Optimization ; Software -
                 Programming Languages - Language Classifications
                 (D.3.2): LD ; General Terms: Algorithms, Languages,
                 Theory, Verification",
}

@Article{Pingali:1986:CFI,
  author =       "Keshav Pingali and Arvind",
  title =        "Clarification of ``{Feeding} Inputs on Demand'' in
                 {Efficient} Demand-Driven Evaluation. Part 1",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "140--141",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5003.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors.
                 {\bf F.3.3}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Data-flow
                 languages. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Optimization. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, LD.",
}

@Article{Misra:1986:AMA,
  author =       "Jayadev Misra",
  title =        "Axioms for Memory Access in Asynchronous Hardware
                 Systems",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "142--153",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5007.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; verification",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf B.3.2}: Hardware, MEMORY
                 STRUCTURES, Design Styles, Sequential-access memory.
                 {\bf B.5.1}: Hardware, REGISTER-TRANSFER-LEVEL
                 IMPLEMENTATION, Design, Memory design. {\bf B.4.3}:
                 Hardware, INPUT/OUTPUT AND DATA COMMUNICATIONS,
                 Interconnections (subsystems), Asynchronous/synchronous
                 operation.",
}

@Article{Gouda:1986:PLN,
  author =       "Mohamed G. Gouda and Chung-Kou Chang",
  title =        "Proving Liveness for Networks of Communicating Finite
                 State Machines",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "1",
  pages =        "154--182",
  month =        jan,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5002.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory; verification",
  subject =      "{\bf B.4.4}: Hardware, INPUT/OUTPUT AND DATA
                 COMMUNICATIONS, Performance Analysis and Design Aids,
                 Formal models. {\bf C.2.2}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS, Network
                 Protocols, Protocol architecture. {\bf C.2.2}: Computer
                 Systems Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Network Protocols, Protocol verification. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Correctness proofs. {\bf F.3.1}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Specifying and
                 Verifying and Reasoning about Programs. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming.",
}

@Article{Chirica:1986:TCI,
  author =       "Laurian M. Chirica and David F. Martin",
  title =        "Toward Compiler Implementation Correctness Proofs",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "2",
  pages =        "185--214",
  month =        apr,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/30847.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; verification",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Algebraic
                 approaches to semantics. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Invariants. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Assertions. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Parsing.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness
                 proofs.",
}

@Article{Spooner:1986:MAR,
  author =       "C. R. Spooner",
  title =        "The {ML} Approach to the Readable All-Purpose
                 Language",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "2",
  pages =        "215--243",
  month =        apr,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5918.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, ML. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features.",
}

@Article{Clarke:1986:AVF,
  author =       "E. M. Clarke and E. A. Emerson and A. P. Sistla",
  title =        "Automatic Verification of Finite-State Concurrent
                 Systems Using Temporal Logic Specifications",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "2",
  pages =        "244--263",
  month =        apr,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Ai/nonmono.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib; Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Nierstrasz.bib",
  note =         "An early version appeared in {\em Proc.~10th ACM
                 Symposium on Principles of Programming Languages},
                 1983",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5399.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency regular processes binder; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification. {\bf F.3.1}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Specifying and
                 Verifying and Reasoning about Programs, Mechanical
                 verification. {\bf F.3.1}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Specifying and
                 Verifying and Reasoning about Programs. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic.",
}

@Article{Sager:1986:SPC,
  author =       "Thomas J. Sager",
  title =        "A Short Proof of a Conjecture of {DeRemer} and
                 {Pennello}",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "2",
  pages =        "264--271",
  month =        apr,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/30850.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Syntax. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Grammar types.
                 {\bf F.4.3}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Formal Languages, Classes defined
                 by grammars or automata.",
}

@Article{Tichy:1986:SR,
  author =       "Walter F. Tichy",
  title =        "Smart Recompilation",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "273--291",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5959.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Software libraries.
                 {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.7}: Software,
                 SOFTWARE ENGINEERING, Distribution and Maintenance,
                 Version control.",
}

@Article{Turchin:1986:CS,
  author =       "Valentin F. Turchin",
  title =        "The Concept of a Supercompiler",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "292--325",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5957.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Refal. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Chandy:1986:ESR,
  author =       "K. M. Chandy and Jayadev Misra",
  title =        "An Example of Stepwise Refinement of Distributed
                 Programs: Quiescence Detection",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "326--343",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5958.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Deadlocks. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Hennessy:1986:PSS,
  author =       "Matthew Hennessy",
  title =        "Proving Systolic Systems Correct",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "344--387",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/5999.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; theory; verification",
  subject =      "{\bf B.7.1}: Hardware, INTEGRATED CIRCUITS, Types and
                 Design Styles, Algorithms implemented in hardware. {\bf
                 D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Mechanical verification. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf D.2.1}: Software,
                 SOFTWARE ENGINEERING, Requirements/Specifications,
                 Languages.",
}

@Article{Apt:1986:CPD,
  author =       "Krzysztof R. Apt",
  title =        "Correctness Proofs of Distributed Termination
                 Algorithms",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "388--405",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/6000.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory; verification",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming, CSP.",
}

@Article{Nielson:1986:TCC,
  author =       "Flemming Nielson and Hanne Riis Nielson",
  title =        "Technical Correspondence: Comments on {Georgeff}'s
                 ``{Transformations and Reduction Strategies for Typed
                 Lambda Expressions}''",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "406--407",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Georgeff:1984:TRS}",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/215007.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 F.4.1}: Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Mathematical Logic, Lambda calculus
                 and related systems.",
}

@Article{Krogh:1986:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "408--411",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 15:04:03 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1986:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "3",
  pages =        "412--415",
  month =        jul,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Reps:1986:GEI,
  author =       "Thomas Reps",
  title =        "{Guest Editor}'s Introduction",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "417--418",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Swinehart:1986:SVC,
  author =       "Daniel Swinehart and Polle Zellweger and Richard Beach
                 and Robert Hagemann",
  title =        "A Structural View of the {Cedar} Programming
                 Environment",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "419--490",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jan 19 14:55:31 1987",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib; Object/Nierstrasz.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/6466.html",
  abstract =     "This paper presents an overview of the Cedar
                 programming environment, focusing on its overall
                 structure-that is, the major components of Cedar and
                 the way they are organized. Cedar supports the
                 development of programs written in a single programming
                 language, also called Cedar. Its primary purpose is to
                 increase the productivity of programmers whose
                 activities include experimental programming and the
                 development of prototype software systems for a
                 high-performance personal computer. The paper
                 emphasizes the extent to which the Cedar language, with
                 run-time support, has influenced the organization,
                 flexibility, usefulness, and stability of the Cedar
                 environment. It highlights the novel system features of
                 Cedar, including automatic storage management of
                 dynamically allocated typed values, a run-time type
                 system that provides run-time access to Cedar data type
                 definitions and allows interpretive manipulation of
                 typed values, and a powerful device-independent imaging
                 model that supports the user interface facilities.
                 Using these discussions to set the context, the paper
                 addresses the language and system features and the
                 methodologies used to facilitate the integration of
                 Cedar applications. A comparison of Cedar with other
                 programming environments further identifies areas where
                 Cedar excels and areas where work remains to be done.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimental programming; experimentation;
                 integrated programming environment; languages;
                 olit-oopl cedar; open operating system; strongly typed
                 programming language",
  owner =        "manning",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments, CEDAR. {\bf D.2.2}: Software,
                 SOFTWARE ENGINEERING, Tools and Techniques. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf D.4.0}: Software,
                 OPERATING SYSTEMS, General. {\bf D.4.7}: Software,
                 OPERATING SYSTEMS, Organization and Design. {\bf H.0}:
                 Information Systems, GENERAL.",
}

@Article{Cooper:1986:IIA,
  author =       "Keith D. Cooper and Ken Kennedy and Linda Torczon",
  title =        "The impact of interprocedural analysis and
                 optimizations in the {R}(n) programming environment",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "491--523",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jan 19 15:05:31 1987",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/6489.html",
  abstract =     "In spite of substantial progress in the theory of
                 interprocedural data flow analysis, few practical
                 compiling systems can afford to apply it to produce
                 more efficient object programs. To perform
                 interprocedural analysis, a compiler needs not only the
                 source code of the module being compiled, but also
                 information about the side effects of every procedure
                 in the program containing that module, even separately
                 compiled procedures. In a conventional batch compiler
                 system, the increase in compilation time required to
                 gather this information would make the whole process
                 impractical. In an integrated programming environment,
                 however, other tools can cooperate with the compiler to
                 compute the necessary interprocedural information
                 incrementally as the program is being developed,
                 decreasing both the overall cost of the analysis and
                 the cost of individual compilations. A central goal of
                 the Rn project at Rice University is to construct a
                 prototype software development environment that is
                 designed to build whole programs, rather than just
                 individual modules. It employs interprocedural analysis
                 and optimization to produce high-quality machine code
                 for whole programs. This paper presents an overview of
                 the methods used by the environment to accomplish this
                 task and discusses the impact of these methods on the
                 various environment components. The responsibilities of
                 each component of the environment for the preparation
                 and use of interprocedural information are presented in
                 detail.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; data flow analysis; design; languages;
                 performance",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Moriconi:1986:PSP,
  author =       "Mark Moriconi and Dwight Hare",
  title =        "The {PegaSys} System: Pictures as Formal Documentation
                 of Large Programs",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "524--546",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Feb 24 09:59:21 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/6478.html",
  abstract =     "PegaSys is an experimental system in which a user
                 formally describes how a program is put together by
                 means of a hierarchically structured collection of
                 pictures, called formal dependency diagrams (FDDs).
                 Icons in an FDD demote a wide range of data and control
                 dependencies among the relatively coarse-grained
                 entities contained in large programs. Dependencies
                 considered atomic with respect to one level in a
                 hierarchy can be decomposed into a number of
                 dependencies at a lower level. Each dependency can be
                 predefined primitive of the FDD language or it can be
                 defined by a PegaSys user in terms of the primitives. A
                 PegaSys user is given the illusion that logical
                 formulas do not exist, even thought PegaSys reasons
                 about them internally. This involves (1) checking
                 whether an FDD is meaningful syntactically, (2)
                 determining whether hierarchical refinements of an FDD
                 are methodologically sound, and (3) deciding whether an
                 FDD hierarchy is logically consistent with the program
                 that it is intended to describe. The techniques used to
                 provide these capabilities are discussed along with the
                 logical properties that enable PegaSys to maintain the
                 user illusion.",
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Ada; data and control dependencies; design; design
                 hierarchy; documentation; experimentation; graphical
                 formalism; languages; mechanical decision procedure;
                 programming in the large; theory; verification",
  owner =        "manning",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments, PegaSys. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques,
                 User interfaces. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Mechanical verification. {\bf D.2.10}: Software,
                 SOFTWARE ENGINEERING, Design.",
}

@Article{Bahlke:1986:PSF,
  author =       "Rolf Bahlke and Gregor Snelting",
  title =        "The {PSG} System: From Formal Language Definitions to
                 Interactive Programming Environments",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "547--576",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 09:41:04 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib; Misc/sigplan.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/20890.html",
  abstract =     "The PSG programming system generator developed at the
                 Technical University of Darmstadt produces interactive,
                 language-specific programming environments from formal
                 language definitions. All language-dependent parts of
                 the environment are generated from an entirely
                 nonprocedural specification of the language's syntax,
                 context conditions, and dynamic semantics. The
                 generated environment consists of a language-based
                 editor, supporting systematic program development by
                 named program fragments, an interpreter, and a fragment
                 library system. The major component of the environment
                 is a full-screen editor, which allows both structure
                 and text editing. In structure mode the editor
                 guarantees prevention of both syntactic and semantic
                 errors, whereas in textual semantic analysis which is
                 based on unification. The algorithm will immediately
                 detect semantic errors even in incomplete program
                 fragments. The dynamic semantics of the language are
                 defined in denotational style using a functional
                 language based on the lambda calculus. Program
                 fragments are compiled to terms of the functional
                 language which are executed by an interpreter. The PSG
                 generator has been used to produce environments for
                 Pascal, ALGOL 60, MODULA-2, and the formal language
                 definition language itself.",
  acknowledgement = ack-pb # " and " # ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; documentation; languages; theory;
                 theory and verification and Hybrid editor and
                 unification-based incremental semantic analysis;
                 verification",
  owner =        "manning",
  review =       "ACM CR 8711-0926",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding, Program editors. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Syntax. {\bf D.2.3}: Software,
                 SOFTWARE ENGINEERING, Coding, Pretty printers. {\bf
                 F.3.2}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages. {\bf
                 F.4.2}: Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Grammars and Other Rewriting Systems,
                 Grammar types. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Parsing. {\bf I.2.3}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Deduction and Theorem Proving, Deduction.",
}

@Article{Horwitz:1986:GEE,
  author =       "Susan Horwitz and Tim Teitelbaum",
  title =        "Generating Editing Environments Based on Relations and
                 Attributes",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "577--608",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 20 11:19:15 1987",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/6512.html",
  abstract =     "The ability to generate language-based editors depends
                 on the existence of a powerful, language-independent
                 model of editing. A model is proposed in which programs
                 are represented as attributed abstract-syntax trees
                 with an associated relational database. Relations can
                 depend on state of the attributed tree, and attributes
                 can depend on the values in relations, provided there
                 are no circular dependencies. The power and the
                 limitations of relational operations are demonstrated
                 with respect to the support of static-semantic
                 checking, anomaly detection, an interrogation facility,
                 and the ability to define alternative program displays.
                 The advantages of the hybrid system over both the
                 purely relational and purely attribute-based systems
                 are presented, and new algorithms are given for query
                 evaluation and incremental view updating motivated by
                 the efficiency requirements of interactive editing
                 under the defined model. A prototype implementation of
                 an editor generator is described, and suggestions for
                 future research are made.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; documentation; languages;
                 relational database; verification and attribute grammar
                 and generating language-based editors and incremental
                 view updating",
  owner =        "manning",
  subject =      "{\bf D.2.3}: Software, SOFTWARE ENGINEERING, Coding,
                 Program editors. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors. {\bf
                 H.2.1}: Information Systems, DATABASE MANAGEMENT,
                 Logical Design, Data models. {\bf H.2.4}: Information
                 Systems, DATABASE MANAGEMENT, Systems, Query
                 processing.",
}

@Article{Anonymous:1986:AI,
  author =       "Anonymous",
  title =        "1986 Author Index",
  journal =      j-TOPLAS,
  volume =       "8",
  number =       "4",
  pages =        "609--610",
  month =        oct,
  year =         "1986",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:41:06 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wing:1987:WLI,
  author =       "Jeannette M. Wing",
  title =        "Writing {Larch} Interface Language Specifications",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "1",
  pages =        "1--24",
  month =        jan,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/10500.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; verification",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Languages. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Larch. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Abstract data types. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Modules, packages. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Procedures, functions, and subroutines. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Pre- and post-conditions. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Carson:1987:GSP,
  author =       "Scott D. Carson and Paul F. {Reynolds, Jr.}",
  title =        "The Geometry of Semaphore Programs",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "1",
  pages =        "25--53",
  month =        jan,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/9759.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Synchronization. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Concurrency.
                 {\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Deadlocks. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Mutual exclusion. {\bf G.2.2}: Mathematics
                 of Computing, DISCRETE MATHEMATICS, Graph Theory, Graph
                 algorithms.",
}

@Article{Broy:1987:ADP,
  author =       "Manfred Broy and Martin Wirsing and Peter Pepper",
  title =        "On the Algebraic Definition of Programming Languages",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "1",
  pages =        "54--99",
  month =        jan,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/10501.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Algebraic approaches to
                 semantics. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory.",
}

@Article{Sokolowski:1987:SHL,
  author =       "Stefan Soko{\l}owski",
  title =        "Soundness of {Hoare}'s Logic: An Automated Proof Using
                 {LCF}",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "1",
  pages =        "100--120",
  month =        jan,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/11326.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic. {\bf I.2.3}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving.",
}

@Article{Cohen:1987:PCU,
  author =       "Jacques Cohen and Timothy J. Hickey",
  title =        "Parsing and Compiling Using {Prolog}",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "125--163",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jun 29 10:47:01 1987",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/22946.html",
  abstract =     "This paper presents the material needed for exposing
                 the reader to the advantages of using Prolog as a
                 language for describing succinctly most of the
                 algorithms needed in prototyping and implementing
                 compilers or producing tools that facilitate this task.
                 The available published material on the subject
                 describes one particular approach in implementing
                 compilers using Prolog. It consists of coupling actions
                 to recursive descent parsers to produce syntax-trees
                 which are subsequently utilized in guiding the
                 generation of assembly language code. Although this
                 remains a worthwhile approach, there is a host of
                 possibilities for Prolog usage in compiler
                 construction. The primary aim of this paper is to
                 demonstrate the use of Prolog in parsing and compiling.
                 A second, but equally important, goal of this paper is
                 to show that Prolog is a labor-saving tool in
                 prototyping and implementing many non-numerical
                 algorithms which arise in compiling, and whose
                 description using Prolog is not available in the
                 literature. The paper discusses the use of unification
                 and nondeterminism in compiler writing as well as means
                 to bypass these (costly) features when they are deemed
                 unnecessary. Topics covered include bottom-up and
                 top-down parsers, syntax-directed translation, grammar
                 properties, parser generation, code generation, and
                 optimizations. Newly proposed features that are useful
                 in compiler construction are also discussed. A
                 knowledge of Prolog is assumed.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; code generation; grammar properties;
                 languages; optimization; parsing; theory;
                 verification",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Prolog. {\bf
                 D.1.0}: Software, PROGRAMMING TECHNIQUES, General.",
}

@Article{Burke:1987:PML,
  author =       "Michael G. Burke and Gerald A. Fisher",
  title =        "A Practical Method for {LR} and {LL} Syntactic Error
                 Diagnosis and Recovery",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "164--197",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jun 29 11:01:25 1987",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/22720.html",
  abstract =     "This paper presents a powerful, practical, and
                 essentially language-independent syntactic error
                 diagnosis and recovery method that is applicable within
                 the frameworks of LR and LL parsing. The method
                 generally issues accurate diagnoses even where multiple
                 errors occur within close proximity, yet seldom issues
                 spurious error messages. It employs a new technique,
                 parse action deferral, that allows the most appropriate
                 recovery in cases where this would ordinarily be
                 precluded by late detection of the error. The method is
                 practical in that it does not impose substantial space
                 or time overhead on the parsing of correct programs,
                 and in that its time efficiency in processing an error
                 allows for it incorporation in a production compiler.
                 The method is language independent, but it does allow
                 for tuning with respect to particular languages and
                 implementations through the setting of
                 language-specific parameters.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; LL parser; LR parser; syntactic
                 error diagnosis; syntactic error recovery; syntactic
                 error repair",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques,
                 User interfaces. {\bf D.2.5}: Software, SOFTWARE
                 ENGINEERING, Testing and Debugging, Error handling and
                 recovery. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing.",
}

@Article{Feather:1987:LSS,
  author =       "Martin S. Feather",
  title =        "Language Support for the Specification and Development
                 of Composite Systems",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "198--234",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jun 29 11:08:03 1987",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/softeng.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/22947.html",
  abstract =     "When a complex system is to be realized as a
                 combination of interacting components, development of
                 those components should commence from a specification
                 of the behavior required of the composite system. A
                 separate specification should be used to describe the
                 decomposition of that system into components. The first
                 phase of implementation from a specification in this
                 style is the derivation of the individual component
                 behaviors implied by these specifications. The virtues
                 of this approach to specification are expounded, and
                 specification language features that are supportive of
                 it are presented. It is shown how these are
                 incorporated in the specification language Gist, which
                 our group has developed. These issues are illustrated
                 in a development of a controller for elevators serving
                 passengers in a multistory building.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "composite systems; design; distributed decomposition;
                 interactive systems; languages; theory; verification",
  owner =        "manning",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Languages. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Gist. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Very high-level languages. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Finkel:1987:DDI,
  author =       "Raphael Finkel and Udi Manber",
  title =        "{DIB} --- a distributed implementation of
                 backtracking",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "235--256",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jun 29 11:22:11 1987",
  bibsource =    "Ai/ai.bib; Ai/nonmono.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24067.html",
  abstract =     "DIB is a general-purpose package that allows a wide
                 range of applications such as recursive backtrack,
                 branch and bound, and alpha-beta search to be
                 implemented on a multicomputer. It is very easy to use.
                 The application program needs to specify only the root
                 of the recursion tree, the computation to be performed
                 at each node, and how to generate children at each
                 node. In addition, the application and how to
                 disseminate information (such as bounds) either
                 globally or locally in the tree. DIB uses a distributed
                 algorithm, transparent to the application programmer,
                 that divides the problem into subproblems and
                 dynamically allocates them to any number of
                 (potentially nonhomogeneous) machines. This algorithm
                 requires only minimal support from the distributed
                 operating system. DIB can recover from failures of
                 machines even if they are not detected DIB currently
                 runs on the Crystal multicomputer at the University of
                 Wisconsin-Madison. Many applications have been
                 implemented quite easily, including exhaustive
                 traversal (N queens, knight's tour, megamax tree
                 evaluation), branch and bound (traveling salesman) and
                 alpha-beta search (the game of NIM). Speedup is
                 excellent for exhaustive traversal and quite good for
                 branch and bound.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; backtracking; branch and bound; design;
                 distributed algorithms; local-area networks; networks
                 of workstations; reliability",
  owner =        "manning",
  subject =      "{\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Distributed applications. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Concurrency. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management,
                 Multiprocessing/multiprogramming. {\bf D.4.5}:
                 Software, OPERATING SYSTEMS, Reliability,
                 Fault-tolerance. {\bf D.4.7}: Software, OPERATING
                 SYSTEMS, Organization and Design, Distributed
                 systems.",
}

@Article{Mueller:1987:RMS,
  author =       "Robert A. Mueller and Joseph Varghese",
  title =        "Retargetable Microcode Synthesis",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "257--276",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jun 29 11:30:12 1987",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/arch.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/23717.html",
  abstract =     "Most work on automating the translation of high-level
                 microprogramming languages into microcode has dealt
                 with lexical and syntactic analysis and the use of
                 manually produced macro tables for code generation. We
                 describe an approach to and some results on the
                 formalization and automation of the more difficult
                 problem of retargeting local code generation in a
                 machine-independent, optimizing microcode synthesis
                 system. Whereas this problem is similar in many ways to
                 that of retargeting local code generation in high-level
                 language compilers, there are some major differences
                 that call for new approaches. The primary issues
                 addressed in this paper are the representation of
                 target microprogrammable machines, the intermediate
                 representation of local microprogram function, and
                 general algorithmic methods for deriving local
                 microcode from target machine and microcode function
                 specifications. Of particular interest are the use of
                 formal semantics and data flow principles in achieving
                 both a general and reasonably efficient solution.
                 Examples of the modeling of a representative horizontal
                 machine (the PUMA) and the generation of microcode for
                 the PUMA machine model from our working implementation
                 are presented.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "data antidependency; data dependency; Design; flow
                 graph; languages; machine description; microcode
                 compaction; microcode generation; microinstruction set
                 processors; microprogramming",
  owner =        "manning",
  subject =      "{\bf B.1.4}: Hardware, CONTROL STRUCTURES AND
                 MICROPROGRAMMING, Microprogram Design Aids, Languages
                 and compilers. {\bf B.1.4}: Hardware, CONTROL
                 STRUCTURES AND MICROPROGRAMMING, Microprogram Design
                 Aids, Machine-independent microcode generation. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Code generation. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Translator
                 writing systems and compiler generators.",
}

@Article{Fraser:1987:ERC,
  author =       "Christopher W. Fraser and Eugene W. Myers",
  title =        "An Editor for Revision Control",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "2",
  pages =        "277--295",
  month =        apr,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 11:07:27 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/22948.html",
  abstract =     "Programming environments support revision control in
                 several guises. Explicitly, revision control softwre
                 manages the trees of revisions that grow as software is
                 modified. Implicitly, editors retain past versions by
                 automatically saving backup copies and by allowing
                 users to undo commands. This paper describes an editor
                 that offers a uniform solution to these problems by
                 never destroying the old version of the file being
                 edited. It represents files using a generalization of
                 AVL trees called ``AVL dags,'' which makes it
                 affordable to automatically retain past versions of
                 files. Automatic retention makes revision maintenance
                 transparent to users. The editor also uses the same
                 command language to edit both text and revision
                 trees.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; Algorithms and design and languages and
                 management and editor and persistent data type; design;
                 languages; management; revision control; undo command",
  owner =        "manning",
  subject =      "{\bf D.2.7}: Software, SOFTWARE ENGINEERING,
                 Distribution and Maintenance, Version control. {\bf
                 D.2.6}: Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 E.1}: Data, DATA STRUCTURES, Lists. {\bf I.7.1}:
                 Computing Methodologies, TEXT PROCESSING, Text
                 Editing.",
}

@Article{Lamb:1987:ISI,
  author =       "David Alex Lamb",
  title =        "{IDL}: Sharing Intermediate Representations",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "297--318",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Aug 21 09:04:21 1987",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24040.html",
  abstract =     "IDL (Interface Description Language) is a practical
                 and useful tool for controlling the exchange of
                 structured data between different components of a large
                 system. IDL is a notation for describing collections of
                 programs and the data structures through which they
                 communicate. Using IDL, a designer gives abstract
                 descriptions of data structures, together with
                 representation specifications that specialize the
                 abstract structures of particular programs. A tool, the
                 IDL translator, generates readers and writers that map
                 between concrete internal representations and abstract
                 exchange representations. data between",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Data representation; data structures; design;
                 input/output; languages; performance; software
                 engineering; system design",
  owner =        "manning",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Run-time environments. {\bf
                 E.2}: Data, DATA STORAGE REPRESENTATIONS. {\bf H.2.3}:
                 Information Systems, DATABASE MANAGEMENT, Languages,
                 Data description languages (DDL).",
}

@Article{Ferrante:1987:PDG,
  author =       "Jeanne Ferrante and Karl J. Ottenstein and Joe D.
                 Warren",
  title =        "The Program Dependence Graph and its Use in
                 Optimization",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "319--349",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 2 13:23:46 1987",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24041.html",
  abstract =     "In this paper, we present an intermediate program
                 representation, called the program dependence
                 graph-PDG-, that makes explicit both the data and
                 control dependences for each operation in a program.
                 Data dependences have been used to represent only the
                 relevant data flow relationships of a program. Control
                 dependences are introduced to analogously represent
                 only the essential control of a program. Control
                 dependences are derived from the usual control flow
                 graph. Many traditional optimizations operate more
                 efficiently on the PDG. Since dependences in the PDG
                 connect computationally related parts of the program, a
                 single walk of these dependences is sufficient to
                 perform many optimizations. The PDG allows
                 transformations such as vectorization, that previously
                 required special treatment of control dependence, to be
                 performed in a manner that is uniform for both control
                 and data dependences. Program transformations that
                 require interaction of the two dependence types can be
                 easily handled with our representation. As an example,
                 an incremental approach to modifying data dependences
                 resulting from branch deletion or loop unrolling is
                 introduced. The PDG supports incremental optimization,
                 permitting transformations to be triggered by one
                 another and applied only to affect dependences.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; branch deletion; code motion; data flow;
                 debugging; dependence analysis; incremental data flow
                 analysis; intermediate program representation; internal
                 program form; languages; loop fusion; loop unrolling;
                 node splitting; parallelism; performance; slicing;
                 vectorization",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Charlesworth:1987:MR,
  author =       "Arthur Charlesworth",
  title =        "The Multiway Rendezvous",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "350--366",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24050.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Mutual exclusion. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.1.3}: Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Concurrency.",
}

@Article{Holt:1987:DDC,
  author =       "Richard C. Holt",
  title =        "Data Descriptors: a Compile-Time Model of Data and
                 Addressing",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "367--389",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 2 13:49:06 1987",
  bibsource =    "Compiler/compiler.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24051.html",
  abstract =     "Data descriptors, which have evolved from Wilcox's
                 value descriptors, are a notation for representing
                 run-time data objects at compile time. One of the
                 principal reasons for developing this notation was to
                 aid in the rapid construction of code generators,
                 especially for new microprocessors. Each data
                 descriptor contains a base, a displacement, and a level
                 of indirection. For example, a variable $x$ lying at
                 displacement 28 from base register B3 is represented by
                 this data descriptor: @B3.28. The general form of a
                 data descriptor is @kb.d.i where $k$ give the number of
                 levels of indirection, $b$ is a base, $d$ is a
                 displacement, and $i$ is an index. Data descriptors are
                 convenient for representing addressing in Fortran ---
                 with static allocation and common blocks-in Pascal and
                 Turing-with automatic allocation and stack frames ---
                 and in more general languages such as Euclid and PL/1.
                 This generality of data descriptors allows code
                 generation to be largely machine independent. This
                 paper gives a machine independent method for storage
                 allocation that uses data descriptors. Techniques are
                 given for local optimization of basic arithmetic and
                 addressing code using data descriptors. Target machine
                 dependencies are isolated so that the part of the code
                 generator that handles high-level addressing-such as
                 subscripting-is machine independent. The techniques
                 described in this paper have proven effective in the
                 rapid development of a number of production code
                 generators.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "addressability; addressing modes; array subscripting;
                 base displacement addressing; code generation; code
                 optimization; compiler structure; compilers; data
                 alignment; data descriptor; display based addressing;
                 language translators; languages; machine idioms;
                 machine-independent code generation; optimal addition;
                 portable compiler; storage allocation",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf E.2}: Data, DATA
                 STORAGE REPRESENTATIONS.",
}

@Article{Yemini:1987:ATE,
  author =       "Shaula Yemini and Daniel M. Berry",
  title =        "An Axiomatic Treatment of Exception Handling in an
                 Expression-Oriented Language",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "390--407",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/obscure.bib",
  note =         "See remarks \cite{Yemini:1988:TCA}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24052.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Control
                 structures. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Control primitives. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, ALGOL-68.",
}

@Article{Reps:1987:SSE,
  author =       "Thomas Reps and Alan Demers",
  title =        "Sublinear-Space Evaluation Algorithms for Attribute
                 Grammars",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "408--440",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 2 13:55:34 1987",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214529.html",
  abstract =     "A major drawback of attribute-grammar-based systems is
                 that they are profligate consumers of storage. This
                 paper concerns new storage-management techniques that
                 reduce the number of attribute values retained at any
                 stage of attribute evaluation; it presents an
                 algorithms for evaluating an $n$-attribute tree that
                 never retains more than $ O - \log n$-attribute values.
                 This method is optimal, although it may require
                 nonlinear time. A second algorithm, which never retains
                 more than $O$-square root $n$-attribute values, it also
                 presented, both as an introduction to the $ O - \log
                 n$-method and because it works in linear time.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; attribute evaluation; attribute grammar
                 and language-based editor and spill file; theory",
  owner =        "manning",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics.",
}

@Article{Banerjee:1987:MSR,
  author =       "Debasish Banerjee",
  title =        "A Methodology for Synthesis of Recursive Functional
                 Programs",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "441--462",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/24071.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Algebraic
                 approaches to semantics. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Denotational semantics. {\bf
                 F.3.3}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Studies of Program Constructs, Functional
                 constructs. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 synthesis.",
}

@Article{Krogh:1987:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "463--466",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 13:43:09 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1987:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "3",
  pages =        "467--470",
  month =        jul,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sonnenschein:1987:GTS,
  author =       "Michael Sonnenschein",
  title =        "Graph Translation Schemes to Generate Compiler Parts",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "473--490",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Feb 15 12:34:06 1988",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/29874.html",
  abstract =     "Graph translation schemes-GTSs-are a generalization of
                 attribute grammars and of some ideas in Koster's
                 language CDL2. They are specially designed to support a
                 compiler writer in defining parts of the back-end of
                 his compiler, but they can also be useful for the
                 specification of the analysis pass of a compiler. GTSs
                 combine elements of functional and of algorithmic
                 specification techniques to allow iterative attribute
                 evaluation and attributing of program graphs. GTSs
                 consist of only a few syntactical elements. We present
                 operational semantics and discuss improvements in the
                 efficiency of the proposed implementation of GTSs.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "attribute grammars; data flow analysis; design;
                 grammars; graph-oriented intermediate languages;
                 languages; program graphs",
  owner =        "manning",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Design languages. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems.",
}

@Article{Allen:1987:ATF,
  author =       "Randy Allen and Ken Kennedy",
  title =        "Automatic Translation of {Fortran} Programs to Vector
                 Form",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "491--542",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Feb 15 12:46:31 1988",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/programming.env.bib; Parallel/par.compiler.bib;
                 Parallel/vectorization.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/29875.html",
  abstract =     "The recent success of vector computers such as the
                 Cray-1 and array processors such as those manufactured
                 by Floating Point Systems has increased interest in
                 making vector operations available to the FORTRAN
                 programmer. The FORTRAN standards committee is
                 currently considering a successor to FORTRAN 77,
                 usually called FORTRAN 8x, that will permit the
                 programmer to explicitly specify vector and array
                 operations. Although FORTRAN 8x will make it convenient
                 to specify explicit vector operations in new programs,
                 it does little for existing code. In order to benefit
                 from the power of vector hardware, existing programs
                 will need to be rewritten in some language, presumably
                 FORTRAN 8x, that permits the explicit specification of
                 vector operations. One way to avoid a massive manual
                 recoding effort is to provide a translator that
                 discovers the parallelism implicit in a FORTRAN program
                 and automatically rewrites that program in FORTRAN 8x.
                 Such a translation from FORTRAN to FORTRAN 8x is not
                 straightforward because FORTRAN DO loops are not always
                 semantically equivalent to the corresponding FORTRAN 8x
                 parallel operation. The semantic difference between
                 these two constructs is precisely captured by the
                 concept of dependence. A translation from FORTRAN to
                 FORTRAN 8x preserves the semantics of the original
                 program if it preserves the dependences in that
                 program. The theoretical background is developed here
                 for employing data dependence to convert FORTRAN
                 programs to parallel form. Dependence is defined and
                 characterized in terms of the conditions that give rise
                 to it; accurate tests to determine dependence are
                 presented; and transformations that use dependence to
                 uncover additional parallelism are discussed.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "detection of parallelism; FORTRAN; language
                 translators; languages; vector computing",
  owner =        "manning",
  subject =      "{\bf D.1.2}: Software, PROGRAMMING TECHNIQUES,
                 Automatic Programming. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Rosenkrantz:1987:EAA,
  author =       "D. J. Rosenkrantz and H. B. Hunt",
  title =        "Efficient Algorithms for Automatic Construction and
                 Compactification of Parsing Grammars",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "543--566",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/29876.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Grammar types. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Decision
                 problems. {\bf D.3.1}: Software, PROGRAMMING LANGUAGES,
                 Formal Definitions and Theory, Syntax. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Translator
                 writing systems and compiler generators. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Parsing.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers.",
}

@Article{Anson:1987:GIC,
  author =       "Ed Anson",
  title =        "A Generalized Iterative Construct and Its Semantics",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "567--581",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/30391.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Correctness proofs.",
}

@Article{Haynes:1987:ECP,
  author =       "Christopher T. Haynes and Daniel P. Friedman",
  title =        "Embedding Continuations in Procedural Objects",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "582--598",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/30392.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; security; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Extensible languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, LISP. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 SCHEME. {\bf D.3.3}: Software, PROGRAMMING LANGUAGES,
                 Language Constructs and Features, Control structures.",
}

@Article{Cuny:1987:CDD,
  author =       "Janice E. Cuny and Lawrence Snyder",
  title =        "Conversion from Data-Driven to Synchronous Execution
                 in Loop Programs",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "599--617",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/31334.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf C.1.2}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors), Multiple-instruction-stream,
                 multiple-data-stream processors (MIMD). {\bf C.1.2}:
                 Computer Systems Organization, PROCESSOR ARCHITECTURES,
                 Multiple Data Stream Architectures (Multiprocessors),
                 Parallel processors. {\bf C.1.3}: Computer Systems
                 Organization, PROCESSOR ARCHITECTURES, Other
                 Architecture Styles, Adaptable architectures. {\bf
                 C.1.3}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Other Architecture Styles, Data-flow
                 architectures. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors.
                 {\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management.",
}

@Article{Bic:1987:DDM,
  author =       "Lubomir Bic and Craig Lee",
  title =        "A Data-Driven Model for a Subset of Logic
                 Programming",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "618--645",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/31333.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; performance; theory",
  subject =      "{\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Logic
                 programming. {\bf F.1.2}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Modes of Computation,
                 Parallelism and concurrency. {\bf I.2.4}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Knowledge
                 Representation Formalisms and Methods, Semantic
                 networks. {\bf C.1.3}: Computer Systems Organization,
                 PROCESSOR ARCHITECTURES, Other Architecture Styles,
                 Data-flow architectures.",
}

@Article{Loeckx:1987:ASC,
  author =       "Jacques Loeckx",
  title =        "Algorithmic Specifications: a Constructive
                 Specification Method for Abstract Data Types",
  journal =      j-TOPLAS,
  volume =       "9",
  number =       "4",
  pages =        "646--685",
  month =        oct,
  year =         "1987",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/30399.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Specification techniques. {\bf F.3.3}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs, Type structure.",
}

@Article{Ryder:1988:IDF,
  author =       "Barbara G. Ryder and Marvin C. Paull",
  title =        "Incremental Data-flow Analysis Algorithms",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "1--50",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42193.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Control structures. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors. {\bf F.2.2}: Theory
                 of Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Andrews:1988:OSL,
  author =       "Gregory R. Andrews and Ronald A. Olsson and Michael
                 Coffin and Irving Elshoff and Kelvin Nilsen and Titus
                 Purdin and Gregg Townsend",
  title =        "An Overview of the {SR} Language and Implementation",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "51--86",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42324.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Distributed applications. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems, Network operating systems. {\bf
                 D.1.3}: Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, SR.",
}

@Article{Hesselink:1988:MAN,
  author =       "W. H. Hesselink",
  title =        "A Mathematical Approach to Nondeterminism in Data
                 Types",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "87--117",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42194.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Abstract data types. {\bf F.1.2}: Theory
                 of Computation, COMPUTATION BY ABSTRACT DEVICES, Modes
                 of Computation, Alternation and nondeterminism. {\bf
                 F.3.3}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Studies of Program Constructs, Type
                 structure.",
}

@Article{Boute:1988:SSP,
  author =       "Raymond T. Boute",
  title =        "System Semantics: Principles, Applications, and
                 Implementation",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "118--155",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/45067.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; documentation; languages; performance;
                 reliability; theory; verification",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Operational
                 semantics. {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Syntax. {\bf
                 I.2.4}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Knowledge Representation Formalisms and
                 Methods, Representation languages. {\bf I.1.3}:
                 Computing Methodologies, ALGEBRAIC MANIPULATION,
                 Languages and Systems, Special-purpose algebraic
                 systems.",
}

@Article{Reed:1988:SVL,
  author =       "Joylyn Reed and Raymond T. Yeh",
  title =        "Specification and Verification of Liveness Properties
                 of Cyclic, Concurrent Processes",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "156--177",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Object/Nierstrasz.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42195.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency liveness; design; verification",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Murphy:1988:NDP,
  author =       "Sandra L. Murphy and A. Udaya Shankar",
  title =        "A Note on the Drinking Philosophers Problem (Technical
                 Correspondence)",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "1",
  pages =        "178--188",
  month =        jan,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hilfinger:1988:APD,
  author =       "Paul N. Hilfinger",
  title =        "An {Ada} Package for Dimensional Analysis",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "189--203",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 17 14:11:24 1988",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Misc/softeng.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42346.html",
  abstract =     "This paper illustrates the use of Ada's abstraction
                 facilities--notably, operator overloading and type
                 parameterization--to define an oft-requested feature: a
                 way to attribute units of measure to variables and
                 values. The definition given allows the programmer to
                 specify units of measure for variables, constants, and
                 parameters; checks uses of these entities for
                 dimensional consistency; allows arithmetic between
                 them, where legal; and provides scale conversions
                 between commensurate units. It is not constrained to a
                 particular system of measurement-such as the metric or
                 English systems. Although the definition is in standard
                 Ada and requires nothing special of the compiler,
                 certain reasonable design choices in the compiler,
                 discussed here at some length, can make its
                 implementation particularly efficient.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dimensional analysis; language design; languages;
                 measurement; reliability; units",
  owner =        "manning",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Ada. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Extensible languages. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Data types and structures. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Modules, packages. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Wirth:1988:TE,
  author =       "Niklaus Wirth",
  title =        "Type Extensions",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "204--214",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/42190.46167",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 17 14:16:02 1988",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/w/wirth-niklaus.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Misc/softeng.bib",
  note =         "See remarks \cite{Cohen:1991:TCT,Wirth:1991:TCR}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/46167.html",
  abstract =     "Software systems represent a hierarchy of modules.
                 Client modules contain sets of procedures that extend
                 the capabilities of imported modules. This concept of
                 extension is here applied to data types. Extended types
                 are related to their ancestor in terms of a hierarchy.
                 Variables of an extended type are compatible with
                 variables of the ancestor type. This scheme is
                 expressed by three language constructs only: the
                 declaration of extended record types, the type test,
                 and the type guard. The facility of extended types,
                 which closely resembles the class concept, is defined
                 in rigorous and concise terms, and an efficient
                 implementation is presented.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  author-dates = "Niklaus Wirth (15 February 1934--1 January 2024)",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Extensible data type; languages; Modula-2",
  numpages =     "11",
  owner =        "manning",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation.",
}

@Article{vandenBos:1988:AIT,
  author =       "Jan {van den Bos}",
  title =        "Abstract Interaction Tools: a Language for User
                 Interface Management Systems",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "215--247",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42191.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "human factors; languages",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, User interfaces. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Input/Output. {\bf H.1.2}: Information
                 Systems, MODELS AND PRINCIPLES, User/Machine Systems,
                 Human factors. {\bf I.3.6}: Computing Methodologies,
                 COMPUTER GRAPHICS, Methodology and Techniques.",
}

@Article{LeMetayer:1988:AAC,
  author =       "Daniel {Le M{\'e}tayer}",
  title =        "{ACE}: An Automatic Complexity Evaluator",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "248--266",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Parallel/Pfpbib.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42347.html",
  abstract =     "There has been a great deal of research done on the
                 evaluation of the complexity of particular algorithms;
                 little effort, however, has been devoted to the
                 mechanization of this evaluation. The ACE (Automatic
                 Complexity Evaluator) system is able to analyze
                 reasonably large programs, like sorting programs, in a
                 fully mechanically way. A time-complexity function is
                 derived from the initial functional program. This
                 function is transformed into its nonrecursive
                 equivalent according to McCarthy's recursion induction
                 principle, using a predefined library of recursive
                 definitions. As the complexity is not a decidable
                 property, this transformation will not be possible in
                 all cases. The richer the predefined library is, the
                 more likely the system is to succeed. The operations
                 performed by ACE are described and the use of the
                 system is illustrated with the analysis of a sorting
                 algorithm. Related works and further improvements are
                 discussed in the conclusion.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Granularity Analysis; languages; measurement;
                 performance",
  subject =      "{\bf D.2.8}: Software, SOFTWARE ENGINEERING, Metrics.
                 {\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 synthesis. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 transformation.",
}

@Article{Lamport:1988:CPB,
  author =       "Leslie Lamport",
  title =        "Control Predicates are Better than Dummy Variables for
                 Reasoning about Program Control",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "267--281",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42348.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Shasha:1988:ECE,
  author =       "Dennis Shasha and Marc Snir",
  title =        "Efficient and Correct Execution of Parallel Programs
                 that Share Memory",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "282--312",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/hash.bib; Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42277.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management. {\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems.",
}

@Article{Greenberg:1988:SEA,
  author =       "Albert G. Greenberg and Boris D. Lubachevsky and
                 Andrew M. Odlyzko",
  title =        "Simple, Efficient, Asynchronous Parallel Algorithms
                 for Maximization",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "313--337",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42278.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf C.1.2}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors), Parallel processors. {\bf C.4}:
                 Computer Systems Organization, PERFORMANCE OF SYSTEMS,
                 Modeling techniques. {\bf G.1.0}: Mathematics of
                 Computing, NUMERICAL ANALYSIS, General, Parallel
                 algorithms.",
}

@Article{Bermudez:1988:NRB,
  author =       "Manuel E. Bermudez and Karl M. Schimpf",
  title =        "On the (non-) Relationship between {SLR}(1) and
                 {NQLALR}(1) Grammars (Technical Correspondence)",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "2",
  pages =        "338--342",
  month =        apr,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/42276.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Syntax. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Translator writing
                 systems and compiler generators. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Parsing.",
}

@Article{Degano:1988:EIL,
  author =       "Pierpaolo Degano and Stefano Mannucci and Bruno
                 Mojana",
  title =        "Efficient Incremental {LR} Parsing for Syntax-Directed
                 Editors",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "345--373",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214503.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding, Program editors. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Syntax.",
}

@Article{Dillon:1988:CET,
  author =       "Laura K. Dillon and George S. Avrunin and Jack C.
                 Wiledon",
  title =        "Constrained Expressions: Toward Broad Applicability of
                 Analysis Methods for Distributed Software Systems",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "374--402",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/44502.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf D.4.7}: Software,
                 OPERATING SYSTEMS, Organization and Design, Distributed
                 systems. {\bf D.3.2}: Software, PROGRAMMING LANGUAGES,
                 Language Classifications, Design languages. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf F.4.3}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Formal Languages, Algebraic language theory.",
}

@Article{Morgan:1988:SS,
  author =       "Carroll Morgan",
  title =        "The Specification Statement",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "403--419",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Misc/Z.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/44503.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "Also reprinted in \cite{Morgan:1988:RC}.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf F.3.1}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs, Pre- and post-conditions. {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Top-down programming. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Correctness proofs.",
}

@Article{Olderog:1988:FPP,
  author =       "Ernst-{R{\"u}diger} Olderog and Krzysztof R. Apt",
  title =        "Fairness in Parallel Programs: The Transformational
                 Approach",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "420--455",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/44504.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; verification",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Concurrency.
                 {\bf F.3.1}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs.",
}

@Article{Mauney:1988:DEL,
  author =       "Jon Mauney and Charles N. Fischer",
  title =        "Determining the Extent of Lookahead in Syntactic Error
                 Repair",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "456--469",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/44505.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers.",
}

@Article{Mitchell:1988:ATE,
  author =       "John C. Mitchell and Gordon D. Plotkin",
  title =        "Abstract Types Have Existential Type",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "470--502",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/prog.lang.theory.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Object/Nierstrasz.bib",
  note =         "Preliminary version appeared in {\em Proc. 12th ACM
                 Symp. on Principles of Programming Languages}, 1985",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/45065.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; types fpl sol binder",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages.",
}

@Article{Yemini:1988:TCA,
  author =       "Shaula Yemini and Daniel M. Berry",
  title =        "Technical Correspondence: ``{An Axiomatic Treatment of
                 Exception Handling in an Expression-Oriented
                 Language}''",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "503--504",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Yemini:1987:ATE}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Krogh:1988:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "504--507",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 15:04:15 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1988:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "3",
  pages =        "508--511",
  month =        jul,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:50:15 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Back:1988:DCA,
  author =       "R. J. R. Back and R. Kurki-Suonio",
  title =        "Distributed Cooperation with Action Systems",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "513--554",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/48023.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems.
                 {\bf F.3.1}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs.",
}

@Article{Inoue:1988:AFP,
  author =       "Katsuro Inoue and Hiroyuki Seki and Hikaru Yagi",
  title =        "Analysis of Functional Programs to Detect Run-Time
                 Garbage Cells",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "555--578",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/absint.bib; Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/48025.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Allocation/deallocation strategies. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf E.2}: Data, DATA STORAGE
                 REPRESENTATIONS, Linked representations.",
}

@Article{Kruskal:1988:ESM,
  author =       "Clyde P. Kruskal and Larry Rudolph and Marc Snir",
  title =        "Efficient Synchronization on Multiprocessors with
                 Shared Memory",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "579--601",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/48024.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; theory; verification",
  subject =      "{\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Parallelism and
                 concurrency. {\bf B.3.2}: Hardware, MEMORY STRUCTURES,
                 Design Styles, Shared memory. {\bf C.1.2}: Computer
                 Systems Organization, PROCESSOR ARCHITECTURES, Multiple
                 Data Stream Architectures (Multiprocessors),
                 Interconnection architectures. {\bf C.1.2}: Computer
                 Systems Organization, PROCESSOR ARCHITECTURES, Multiple
                 Data Stream Architectures (Multiprocessors),
                 Multiple-instruction-stream, multiple-data-stream
                 processors (MIMD). {\bf C.1.2}: Computer Systems
                 Organization, PROCESSOR ARCHITECTURES, Multiple Data
                 Stream Architectures (Multiprocessors), Parallel
                 processors.",
}

@Article{Kennaway:1988:DSC,
  author =       "Richard Kennaway and Ronan Sleep",
  title =        "Director Strings as Combinators",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "602--626",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See corrigendum \cite{Kennaway:1989:CDS}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/48026.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages.",
}

@Article{Schwanke:1988:SR,
  author =       "Robert W. Schwanke and Gail E. Kaiser",
  title =        "Smarter Recompilation",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "627--632",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See remarks \cite{Tichy:1988:TCT}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214505.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Software libraries.
                 {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.7}: Software,
                 SOFTWARE ENGINEERING, Distribution and Maintenance,
                 Version control.",
}

@Article{Tichy:1988:TCT,
  author =       "Walter F. Tichy",
  title =        "Technical Correspondence: {Tichy}'s Response to {R. W.
                 Schwanke} and {G. E. Kaiser}'s ``{Smarter
                 Recompilation}''",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "633--634",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Schwanke:1988:SR}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214507.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Software libraries.
                 {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.7}: Software,
                 SOFTWARE ENGINEERING, Distribution and Maintenance,
                 Version control.",
}

@Article{Drechsler:1988:TCS,
  author =       "Karl-Heinz Drechsler and Manfred P. Stadel",
  title =        "Technical Correspondence: a Solution to a Problem with
                 {Morel} and {Renvoise}'s ``{Global Optimization by
                 Suppression of Partial Redundancies}''",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "635--640",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See remark \cite{Sorkin:1989:TCS}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214509.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Anonymous:1988:AI,
  author =       "Anonymous",
  title =        "1988 Author Index",
  journal =      j-TOPLAS,
  volume =       "10",
  number =       "4",
  pages =        "641--642",
  month =        oct,
  year =         "1988",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 13:53:44 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Steenkiste:1989:SIR,
  author =       "Peter A. Steenkiste and John L. Hennessy",
  title =        "A Simple Interprocedural Register Allocation Algorithm
                 and Its Effectiveness for {Lisp}",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "1--32",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 13 17:16:20 MDT 1994",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Misc/sigplan.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/59289.html",
  acknowledgement = ack-pb # " and " # ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; measurement; performance",
  review =       "ACM CR 8909-0658",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 C.0}: Computer Systems Organization, GENERAL,
                 Hardware/software interfaces. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 LISP.",
}

@Article{Myers:1989:RRA,
  author =       "Eugene W. Myers and Webb Miller",
  title =        "Row Replacement Algorithms for Screen Editors",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "33--56",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/59290.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance",
  subject =      "{\bf D.2.3}: Software, SOFTWARE ENGINEERING, Coding,
                 Program editors. {\bf I.2.8}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Problem Solving, Control
                 Methods, and Search, Dynamic programming. {\bf D.4.4}:
                 Software, OPERATING SYSTEMS, Communications Management,
                 Input/Output. {\bf F.2.2}: Theory of Computation,
                 ANALYSIS OF ALGORITHMS AND PROBLEM COMPLEXITY,
                 Nonnumerical Algorithms and Problems, Computations on
                 discrete structures.",
}

@Article{Bernstein:1989:SEP,
  author =       "David Bernstein and Izidor Gertner",
  title =        "Scheduling Expressions on a Pipelined Processor with a
                 Maximal Delay of One Cycle",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "57--66",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Parallel/scheduling.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/59291.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; performance",
  subject =      "{\bf C.1.2}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors), Pipeline processors. {\bf D.4.7}:
                 Software, OPERATING SYSTEMS, Organization and Design,
                 Hierarchical design. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Code generation. {\bf F.2.2}:
                 Theory of Computation, ANALYSIS OF ALGORITHMS AND
                 PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems, Sequencing and scheduling.",
}

@Article{Steensgaard-Madsen:1989:TRO,
  author =       "J. Steensgaard-Madsen",
  title =        "Type Representation of Objects by Functions",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "67--89",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77345.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Lambda
                 calculus and related systems. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Functional constructs.",
}

@Article{Fischer:1989:DFA,
  author =       "Michael J. Fischer and Nancy A. Lynch and James E.
                 Burns and Allan Borodin",
  title =        "Distributed {FIFO} Allocation of Identical Resources
                 Using Small Shared Space",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "90--114",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/59292.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Scheduling. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems, Distributed applications. {\bf
                 C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Network operating systems. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Concurrency.
                 {\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Mutual exclusion. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Synchronization.
                 {\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Parallelism and
                 concurrency.",
}

@Article{Ait-Kaci:1989:EIL,
  author =       "Hassan {A{\"{}\i}t}-Kaci and Robert Boyer and Patrick
                 Lincoln and Roger Nasr",
  title =        "Efficient Implementation of Lattice Operations",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "115--146",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/59293.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf I.2.4}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Knowledge Representation
                 Formalisms and Methods, Frames and scripts. {\bf
                 H.3.3}: Information Systems, INFORMATION STORAGE AND
                 RETRIEVAL, Information Search and Retrieval,
                 Clustering.",
}

@Article{Alpern:1989:VTP,
  author =       "Bowen Alpern and Fred B. Schneider",
  title =        "Verifying Temporal Properties without Temporal Logic",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "1",
  pages =        "147--167",
  month =        jan,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/62028.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf D.2.1}: Software,
                 SOFTWARE ENGINEERING, Requirements/Specifications,
                 Methodologies. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness proofs.
                 {\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf F.1.1}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Models of Computation,
                 Automata.",
}

@Article{Kaiser:1989:IDS,
  author =       "Gail E. Kaiser",
  title =        "Incremental Dynamic Semantics for Language-Based
                 Programming Environments",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "169--193",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63400.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; reliability; theory",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types. {\bf D.2.3}:
                 Software, SOFTWARE ENGINEERING, Coding, Program
                 editors. {\bf D.2.5}: Software, SOFTWARE ENGINEERING,
                 Testing and Debugging, Debugging aids. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Cameron:1989:EHL,
  author =       "Robert D. Cameron",
  title =        "Efficient High-Level Iteration with Accumulators",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "194--211",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63401.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures.",
}

@Article{LaLonde:1989:DFD,
  author =       "Wilf R. LaLonde",
  title =        "Designing Families of Data Types Using Exemplars",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "212--248",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63265.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.2.10}: Software, SOFTWARE ENGINEERING, Design,
                 Methodologies. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques.",
}

@Article{Weihl:1989:LAP,
  author =       "William E. Weihl",
  title =        "Local Atomicity Properties: Modular Concurrency
                 Control for Abstract Data Types",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "249--283",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63518.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; reliability; theory; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf D.4.5}: Software,
                 OPERATING SYSTEMS, Reliability, Fault-tolerance. {\bf
                 C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Distributed databases. {\bf H.2.4}: Information
                 Systems, DATABASE MANAGEMENT, Systems, Transaction
                 processing.",
}

@Article{Carchiolo:1989:ELT,
  author =       "Vincenza Carchiolo and Antonella {Di Stefano} and
                 Alberto Faro and Giuseppe Pappalardo",
  title =        "{ECCS} and {LIPS}: Two Languages for {OSI} Systems
                 Specification and Verification",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "284--329",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63402.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf C.2.0}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, General, Open System
                 Interconnection reference model (OSI). {\bf D.2.1}:
                 Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Languages. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs.
                 {\bf C.2.2}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Protocols,
                 Protocol verification.",
}

@Article{Burns:1989:USS,
  author =       "James E. Burns and Jan Pachi",
  title =        "Uniform Self-Stabilizing Rings",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "2",
  pages =        "330--344",
  month =        apr,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/63403.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; reliability; theory",
  subject =      "{\bf F.1.1}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Models of Computation, Automata. {\bf
                 C.2.5}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Local Networks, Rings.
                 {\bf C.2.2}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Protocols.",
}

@Article{Horwitz:1989:INV,
  author =       "Susan Horwitz and Jan Prins and Thomas Reps",
  title =        "Integrating Noninterfering Versions of Programs",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "345--387",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/65980.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; management",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding, Program editors. {\bf D.2.7}:
                 Software, SOFTWARE ENGINEERING, Distribution and
                 Maintenance, Restructuring. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.2.7}: Software, SOFTWARE ENGINEERING, Distribution
                 and Maintenance, Version control.",
}

@Article{Brent:1989:EIF,
  author =       "R. P. Brent",
  title =        "Efficient Implementation of the First-Fit Strategy for
                 Dynamic Storage Allocation",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "388--403",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/65981.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Allocation/deallocation strategies. {\bf
                 D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Main memory.",
}

@Article{Anger:1989:LIC,
  author =       "Frank D. Anger",
  title =        "On {Lamport}'s Interprocessor Communication Model",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "404--417",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/65982.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; theory",
  subject =      "{\bf D.4.8}: Software, OPERATING SYSTEMS, Performance,
                 Modeling and prediction. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Mutual
                 exclusion. {\bf D.4.7}: Software, OPERATING SYSTEMS,
                 Organization and Design, Distributed systems. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Synchronization. {\bf D.4.4}: Software,
                 OPERATING SYSTEMS, Communications Management, Network
                 communication. {\bf F.2.2}: Theory of Computation,
                 ANALYSIS OF ALGORITHMS AND PROBLEM COMPLEXITY,
                 Nonnumerical Algorithms and Problems, Sequencing and
                 scheduling.",
}

@Article{Debray:1989:SIM,
  author =       "Saumya K. Debray",
  title =        "Static Inference of Modes and Data Dependencies in
                 Logic Programs",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "418--450",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/absint.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/65983.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance; theory;
                 verification",
  subject =      "{\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Logic
                 programming. {\bf I.2.4}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Knowledge Representation
                 Formalisms and Methods, Predicate logic. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf F.3.3}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs, Type
                 structure.",
}

@Article{Debray:1989:FCL,
  author =       "Saumya K. Debray and David S. Warren",
  title =        "Functional Computations in Logic Programs",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "451--481",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/65984.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance;
                 verification",
  subject =      "{\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Logic
                 programming. {\bf D.2.8}: Software, SOFTWARE
                 ENGINEERING, Metrics, Performance measures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Kennaway:1989:CDS,
  author =       "Richard Kennaway and Ronan Sleep",
  title =        "Corrigendum: ``{Director Strings as Combinators}''",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "482--482",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Kennaway:1988:DSC}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Krogh:1989:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "483--486",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 15:04:22 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1989:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "3",
  pages =        "487--490",
  month =        jul,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Aho:1989:CGU,
  author =       "Alfred V. Aho and Mahadevan Ganapathi and Steven W. K.
                 Tjiang",
  title =        "Code Generation Using Tree Matching and Dynamic
                 Programming",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "491--516",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 Database/Graefe.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/75700.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; comparison of alternative covers of
                 original expression; design; experimentation;
                 languages; matching multiple trees using finite state
                 automata; reduction rules: complex expression
                 $\rightarrow$ single instruction cost; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, twig. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Code generation. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nonprocedural languages. {\bf F.2.2}:
                 Theory of Computation, ANALYSIS OF ALGORITHMS AND
                 PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems, Pattern matching. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Parallel
                 rewriting systems. {\bf I.2.8}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Problem
                 Solving, Control Methods, and Search, Dynamic
                 programming.",
}

@Article{Nelson:1989:GDC,
  author =       "Greg Nelson",
  title =        "A Generalization of {Dijkstra}'s Calculus",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "517--561",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69559.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory.",
}

@Article{Barbosa:1989:CHL,
  author =       "Valmir Barbosa and Eli Gafni",
  title =        "Concurrency in Heavily Loaded Neighborhood-Constrained
                 Systems",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "562--584",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69560.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf F.2.2}: Theory of Computation, ANALYSIS OF
                 ALGORITHMS AND PROBLEM COMPLEXITY, Nonnumerical
                 Algorithms and Problems, Sequencing and scheduling.
                 {\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Parallelism and
                 concurrency. {\bf G.2.2}: Mathematics of Computing,
                 DISCRETE MATHEMATICS, Graph Theory, Network problems.
                 {\bf F.4.3}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Formal Languages, Decision
                 problems.",
}

@Article{Bagrodia:1989:SAP,
  author =       "Rajive Bagrodia",
  title =        "Synchronization of Asynchronous Processes in {CSP}",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "585--597",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69561.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; management",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.4.4}: Software, OPERATING SYSTEMS,
                 Communications Management, Message sending. {\bf
                 F.2.2}: Theory of Computation, ANALYSIS OF ALGORITHMS
                 AND PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems, Sequencing and scheduling. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Synchronization.",
}

@Article{Arvind:1989:SDS,
  author =       "Arvind and Rishiyur S. Nikhil and Keshav K. Pingali",
  title =        "{I}-Structures: Data Structures for Parallel
                 Computing",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "598--632",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 2 18:50:35 2000",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69562.html",
  abstract =     "It is difficult simultaneously to achieve elegance,
                 efficiency and parallelism in functional programs that
                 manipulate large data structures. We demonstrate this
                 through careful analysis of program examples using
                 three common functional data-structuring approaches -
                 lists using Cons and arrays using Update (both
                 fine-grained operators), and arrays using make-array (a
                 ``bulk'' operator). We then present I-structures as an
                 alternative, defining precisely the parallel
                 operational semantics of Id, a language with
                 I-structures. We show elegant, efficient and parallel
                 solutions for the program examples in Id. I-structures
                 make the language non-functional, but do not raise
                 determinancy issues. Finally, we show that even in the
                 context of purely functional languages, I-structures
                 are invaluable for implementing functional data
                 abstractions.",
  acknowledgement = ack-pb # " and " # ack-meo,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  annote =       "First appeared in Graph Reduction: Proceedings of a
                 Workshop at Santa F{\'e}, New Mexico, 1987, ISBN:
                 0-387-18420-1, pages 336--369 and as Cornell
                 University, Computer Science Department technical
                 report TR87-810, 1987.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf E.1}: Data, DATA STRUCTURES, Arrays. {\bf E.1}:
                 Data, DATA STRUCTURES, Lists.",
  xxnote =       "Yes, the primary author has only a single name.",
}

@Article{Sijtsma:1989:PRL,
  author =       "Ben A. Sijtsma",
  title =        "{On the Productivity of Recursive List Definitions}",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "633--649",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Parallel/Pfpbib.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69563.html",
  abstract =     "Several related notions of the productivity are
                 presented for functional languages with lazy
                 evaluation. The notion of productivity captures the
                 idea of computability, of progress of infinite-list
                 programs. If an infinite-list program is {\em
                 productive}, then every element of the list can be
                 computed in finite ``time''. These notions are used to
                 study recursive list definitions, that is, lists
                 defined by $l$ where $ l = f l$. Sufficient conditions
                 are given in terms of the function $f$ that either
                 guarantee the productivity of the list or its
                 unproductivity. Furthermore, a calculus is developed
                 that can be used in verifying that lists defined by $ l
                 \mbox {\em where } l = f l$ are productive. The power
                 and the usefulness of our theory are demonstrated by
                 several nontrivial examples. Several observations are
                 given in conclusion.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; Circular Programs; languages",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Program and recursion schemes. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic, Computability theory. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative languages.",
}

@Article{Nicholson:1989:DSP,
  author =       "Tim Nicholson and Norman Foo",
  title =        "A Denotational Semantics for {Prolog}",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "650--665",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See also remarks in \cite{Finlay:1993:TCC}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/69564.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.4.1}: Theory
                 of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Prolog. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Logic programming.",
}

@Article{Sorkin:1989:TCS,
  author =       "Arthur Sorkin",
  title =        "Technical Correspondence: Some Comments on ``{A
                 Solution to a Problem with Morel and Renvoise's
                 ``Global Optimization by Suppression of Partial
                 Redundancies''}''",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "666--668",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See \cite{Drechsler:1988:TCS}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214513.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Anonymous:1989:AI,
  author =       "Anonymous",
  title =        "1989 Author Index",
  journal =      j-TOPLAS,
  volume =       "11",
  number =       "4",
  pages =        "669--670",
  month =        oct,
  year =         "1989",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:00:28 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Clemm:1990:MEI,
  author =       "Geoffrey Clemm and Leon Osterweil",
  title =        "A Mechanism for Environment Integration",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "1--25",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Misc/scm.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77607.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation; languages; obms; odin; scm:;
                 sde",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.2}: Software,
                 SOFTWARE ENGINEERING, Tools and Techniques. {\bf
                 D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management.",
}

@Article{Horwitz:1990:ISU,
  author =       "Susan Horwitz and Thomas Reps and David Binkley",
  title =        "Interprocedural Slicing Using Dependence Graphs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "26--60",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77608.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Program and recursion schemes. {\bf G.2.2}: Mathematics
                 of Computing, DISCRETE MATHEMATICS, Graph Theory, Graph
                 algorithms. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types.",
}

@Article{Waddle:1990:PTC,
  author =       "Vance E. Waddle",
  title =        "Production Trees: a Compact Representation of Parsed
                 Programs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "61--83",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77609.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; measurement; theory",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing.",
}

@Article{Korach:1990:MTD,
  author =       "E. Korach and S. Kutten and S. Moran",
  title =        "A Modular Technique for the Design of Efficient
                 Distributed Leader Finding Algorithms",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "84--101",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77610.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf G.2.2}: Mathematics of Computing, DISCRETE
                 MATHEMATICS, Graph Theory, Network problems. {\bf
                 F.2.2}: Theory of Computation, ANALYSIS OF ALGORITHMS
                 AND PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems, Sequencing and scheduling. {\bf F.1.1}:
                 Theory of Computation, COMPUTATION BY ABSTRACT DEVICES,
                 Models of Computation, Unbounded-action devices.",
}

@Article{Huang:1990:DDD,
  author =       "Shing-Tsaan Huang",
  title =        "A Distributed Deadlock Detection Algorithm for
                 {CSP}-Like Communication",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "102--122",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77611.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance; theory",
  subject =      "{\bf D.4.7}: Software, OPERATING SYSTEMS, Organization
                 and Design, Distributed systems. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Deadlocks. {\bf
                 D.4.4}: Software, OPERATING SYSTEMS, Communications
                 Management, Message sending. {\bf G.2.2}: Mathematics
                 of Computing, DISCRETE MATHEMATICS, Graph Theory,
                 Network problems.",
}

@Article{Farmer:1990:CPC,
  author =       "William M. Farmer and John D. Ramsdell and Ronald J.
                 Watro",
  title =        "A Correctness Proof for Combinator Reduction with
                 Cycles",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "123--134",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/77612.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Lambda
                 calculus and related systems. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems. {\bf G.2.2}:
                 Mathematics of Computing, DISCRETE MATHEMATICS, Graph
                 Theory. {\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages.",
}

@Article{Burton:1990:TCT,
  author =       "F. Warren Burton",
  title =        "Technical Correspondence: Type Extension Through
                 Polymorphism",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "135--138",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See \cite{Volpano:1991:TCS,Burton:1991:TCA}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214515.html;
                 http://www.acm.org/pubs/toc/Abstracts/0164-0925/77560.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Modules, packages.",
}

@Article{Parnas:1990:TCI,
  author =       "David L. Parnas",
  title =        "Technical Correspondence: On Iterative Constructs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "1",
  pages =        "139--141",
  month =        jan,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214517.html;
                 http://www.acm.org/pubs/toc/Abstracts/0164-0925/77613.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Myers:1990:CUI,
  author =       "Brad A. Myers",
  title =        "Creating User Interfaces Using Programming by Example,
                 Visual Programming, and Constraints",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "143--177",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78943.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; human factors",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, User interfaces. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments,
                 Interactive. {\bf I.3.6}: Computing Methodologies,
                 COMPUTER GRAPHICS, Methodology and Techniques,
                 Interaction techniques. {\bf H.1.2}: Information
                 Systems, MODELS AND PRINCIPLES, User/Machine Systems.
                 {\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 synthesis.",
}

@Article{Weihl:1990:LSA,
  author =       "William E. Weihl",
  title =        "Linguistic Support for Atomic Data Types",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "178--202",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78944.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; reliability",
  subject =      "{\bf H.2.4}: Information Systems, DATABASE MANAGEMENT,
                 Systems, Transaction processing. {\bf H.2.4}:
                 Information Systems, DATABASE MANAGEMENT, Systems,
                 Concurrency. {\bf H.2.4}: Information Systems, DATABASE
                 MANAGEMENT, Systems, Distributed systems. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Abstract data types. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Synchronization. {\bf D.4.5}: Software, OPERATING
                 SYSTEMS, Reliability, Fault-tolerance.",
}

@Article{Knapp:1990:EFD,
  author =       "Edgar Knapp",
  title =        "An Exercise in the Formal Derivation of Parallel
                 Programs: Maximum Flows in Graphs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "203--223",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78945.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Parallelism and
                 concurrency. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Alternation and
                 nondeterminism. {\bf G.2.2}: Mathematics of Computing,
                 DISCRETE MATHEMATICS, Graph Theory. {\bf F.2.2}: Theory
                 of Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems,
                 Sequencing and scheduling.",
}

@Article{Darlington:1990:SDG,
  author =       "Jared L. Darlington",
  title =        "Search Direction by Goal Failure in Goal-Oriented
                 Programming",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "224--252",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78946.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages",
  subject =      "{\bf I.2.3}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Deduction and Theorem Proving, Logic
                 programming. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming.",
}

@Article{Bossi:1990:MSL,
  author =       "A. Bossi and N. Cocco and S. Dulli",
  title =        "A Method for Specializing Logic Programs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "253--302",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/partial-eval.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Theory/CLiCS.bib;
                 Theory/partial-eval.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78947.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; verification",
  subject =      "{\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf I.2.3}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Deduction and Theorem Proving,
                 Logic programming. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness
                 proofs.",
}

@Article{Aggarwal:1990:ALP,
  author =       "S. Aggarwal and C. Courcoubetis and P. Wolper",
  title =        "Adding Liveness Properties to Coupled Finite-State
                 Machines",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "2",
  pages =        "303--339",
  month =        apr,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78948.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; verification",
  subject =      "{\bf C.2.2}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Protocols,
                 Protocol verification. {\bf F.1.1}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Models of
                 Computation, Automata. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Mechanical verification. {\bf D.2.4}: Software,
                 SOFTWARE ENGINEERING, Program Verification, Correctness
                 proofs. {\bf C.4}: Computer Systems Organization,
                 PERFORMANCE OF SYSTEMS, Modeling techniques.",
}

@Article{Burke:1990:IBA,
  author =       "Michael Burke",
  title =        "An Interval-Based Approach to Exhaustive and
                 Incremental Interprocedural Data-Flow Analysis",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "341--395",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/absint.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78963.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 G.2.2}: Mathematics of Computing, DISCRETE MATHEMATICS,
                 Graph Theory. {\bf F.3.3}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs.",
}

@Article{Lamport:1990:WSP,
  author =       "Leslie Lamport",
  title =        "{\sl win\/} and {\sl sin\/}: Predicate Transformers
                 for Concurrency",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "396--428",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78970.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Assertions. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Invariants. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming.",
}

@Article{Jones:1990:EEC,
  author =       "Larry G. Jones",
  title =        "Efficient Evaluation of Circular Attribute Grammars",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "429--462",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78971.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems.",
}

@Article{Herlihy:1990:LCC,
  author =       "Maurice P. Herlihy and Jeannette M. Wing",
  title =        "Linearizability: a Correctness Condition for
                 Concurrent Objects",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "463--492",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/78972.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; theory; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications. {\bf F.1.2}:
                 Theory of Computation, COMPUTATION BY ABSTRACT DEVICES,
                 Modes of Computation. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Krogh:1990:AAP,
  author =       "F. T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "493--496",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 14:04:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1990:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "3",
  pages =        "497--500",
  month =        jul,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:04:27 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chow:1990:PBC,
  author =       "Fred C. Chow and John L. Hennessy",
  title =        "The Priority-Based Coloring Approach to Register
                 Allocation",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "501--536",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/88621.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 C.0}: Computer Systems Organization, GENERAL,
                 Hardware/software interfaces.",
}

@Article{Stamos:1990:RE,
  author =       "James W. Stamos and David K. Gifford",
  title =        "Remote Evaluation",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "537--565",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib; Object/Ooos.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/88631.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; performance",
  subject =      "{\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems.
                 {\bf C.2.1}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Architecture
                 and Design, Distributed networks. {\bf D.4.7}:
                 Software, OPERATING SYSTEMS, Organization and Design,
                 Distributed systems.",
}

@Article{Dewan:1990:ASA,
  author =       "Prasun Dewan and Marvin Solomon",
  title =        "An Approach to Support Automatic Generation of User
                 Interfaces",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "566--609",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214518.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.2}: Software,
                 SOFTWARE ENGINEERING, Tools and Techniques, User
                 interfaces. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features.",
}

@Article{Leiss:1990:KME,
  author =       "Hans Leiss",
  title =        "On {Kilbury}'s Modification of {Earley}'s Algorithm",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "610--640",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/88637.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types.",
}

@Article{Perry:1990:GEI,
  author =       "Dewayne E. Perry",
  title =        "{Guest Editor}'s Introduction",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "641--642",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dillon:1990:USE,
  author =       "Laura K. Dillon",
  title =        "Using Symbolic Execution for Verification of {Ada}
                 Tasking Programs",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "643--669",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/96551.html",
  abstract =     "A method is presented for using symbolic execution to
                 generate the verification conditions required for
                 proving correctness of programs written in a tasking
                 subset of Ada. The symbolic execution rules are derived
                 from proof systems that allow tasks to be verified
                 independently in local proofs, which are then checked
                 for cooperation. The isolation nature of this approach
                 to symbolic execution of concurrent programs makes it
                 better suited to formal verification than the more
                 traditional interleaving approach, which suffers from
                 combinatorial problems. The criteria for correct
                 operation of a concurrent program include partial
                 correctness, as well as more general safety properties,
                 such as mutual exclusion and freedom from deadlock.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.2.5}:
                 Software, SOFTWARE ENGINEERING, Testing and Debugging,
                 Symbolic execution. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Ada. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming.",
}

@Article{Wileden:1990:CEO,
  author =       "Jack C. Wileden and Lori A. Clarke and Alexander L.
                 Wolf",
  title =        "A Comparative Evaluation of Object Definition
                 Techniques for Large Prototype Systems",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "670--699",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See corrigenda \cite{Wileden:1991:CCE}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/88639.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation; languages",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.m}: Software,
                 SOFTWARE ENGINEERING, Miscellaneous, Rapid prototyping.
                 {\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Abstract data types.",
}

@Article{Anonymous:1990:AI,
  author =       "Anonymous",
  title =        "1990 Author Index",
  journal =      j-TOPLAS,
  volume =       "12",
  number =       "4",
  pages =        "700--701",
  month =        oct,
  year =         "1990",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:05:08 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Quong:1991:LPI,
  author =       "Russell W. Quong and Mark A. Linton",
  title =        "Linking Programs Incrementally",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "1--20",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102804.html",
  abstract =     "Linking is traditionally a batch process that resolves
                 cross-references between object modules and run-time
                 libraries to produce a stand-alone executable image.
                 Because most program changes only involve a small part
                 of the program, we have implemented an incremental
                 linker, named Inclink, that processes only the changed
                 modules. Inclink generates a new executable in time
                 proportional to the size of change; in contrast, a
                 batch linker generates an executable in time
                 proportional to the size of the program. To minimize
                 updates to the executable, Inclink allocates extra
                 space for every module. By allocating 24 percent more
                 space in the executable for overflows, Inclink can
                 update a module in place over 97 percent of the time.
                 Measurements show that Inclink is more than an order of
                 magnitude faster than the UNIX [2] batch linker and
                 that 88 percent of all links will take less than 2~s of
                 CPU time on a MicroVAX-2, independent of program
                 size.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; measurement; performance",
  subject =      "{\bf D.4.9}: Software, OPERATING SYSTEMS, Systems
                 Programs and Utilities, Linkers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Run-time
                 environments. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages.",
}

@Article{Fradet:1991:CFL,
  author =       "Pascal Fradet and Daniel {Le M{\'e}tayer}",
  title =        "Compilation of Functional Languages by Program
                 Transformation",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "21--51",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/absint.bib; Compiler/Compiler.Lins.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102805.html",
  abstract =     "One of the most important issues concerning functional
                 languages is the efficiency and the correctness of
                 their implementation. We focus on sequential
                 implementations for conventional von Neumann computers.
                 The compilation process is described in terms of
                 program transformations in the functional framework.
                 The original functional expression is transformed into
                 a functional term that can be seen as a traditional
                 machine code. The two main steps are the compilation of
                 the computation rule by the introduction of
                 continuation functions and the compilation of the
                 environment management using combinators. The advantage
                 of this approach is that we do not have to introduce an
                 abstract machine, which makes correctness proofs much
                 simpler. As far as efficiency is concerned, this
                 approach is promising since many optimizations can be
                 described and formally justified in the functional
                 framework.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; verification",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf I.2.2}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Automatic Programming, Program transformation.",
}

@Article{Waters:1991:ATS,
  author =       "Richard C. Waters",
  title =        "Automatic Transformation of Series Expressions into
                 Loops",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "52--98",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102806.html",
  abstract =     "The benefits of programming in a functional style are
                 well known. In particular, algorithms that are
                 expressed as compositions of functions operating on
                 sequences/vectors/streams of data elements are easier
                 to understand and modify than equivalent algorithms
                 expressed as loops. Unfortunately, this kind of
                 expression is not used anywhere near as often as it
                 could be, for at least three reasons: (1) most
                 programmers are less familiar with this kind of
                 expression than with loops; (2) most programming
                 languages provide poor support for this kind of
                 expression; and (3) when support is provided, it is
                 seldom efficient.\par

                 In any programming language, the second and third
                 problems can be largely solved by introducing a data
                 type called {\em series}, a comprehensive set of
                 procedures operating on series, and a preprocessor (or
                 compiler extension) that automatically converts most
                 series expressions into efficient loops. A set of
                 restrictions specifies which series expressions can be
                 optimized. If programmers stay within the limits
                 imposed, they are guaranteed of high efficiency at all
                 times.\par

                 A common Lisp macro package supporting series has been
                 in use for some time. A prototype demonstrates that
                 series can be straightforwardly supported in Pascal.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors.",
}

@Article{Brogi:1991:CLS,
  author =       "Antonio Brogi and Paolo Ciancarini",
  title =        "The Concurrent Language, {Shared Prolog}",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "99--123",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102807.html",
  abstract =     "Shared Prolog is a new concurrent logic language. A
                 Shared Prolog system is composed of a set of parallel
                 agents that are Prolog programs extended by a guard
                 mechanism. The programmer controls the granularity of
                 parallelism, coordinating communication and
                 synchronization of the agents via a centralized data
                 structure. The communication mechanism is inherited
                 from the blackboard model of problem solving.
                 Intuitively, the granularity of the logic processes to
                 be elaborated in parallel is large, while the resources
                 shared on the blackboard can be very fined
                 grained.\par

                 An operational semantics for Shared Prolog is given in
                 terms of a distributed model. Through an abstract
                 notion of computation, the kinds of parallelism
                 supported by the language, as well as properties of
                 infinite computations, such as local deadlocks, are
                 studied.\par

                 The expressiveness of the language is shown with
                 respect to the specification of two classes of
                 applications: metaprogramming and blackboard systems.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications. {\bf I.2.3}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Deduction and Theorem Proving,
                 Logic programming. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Logic programming.",
}

@Article{Herlihy:1991:WFS,
  author =       "Maurice Herlihy",
  title =        "Wait-Free Synchronization",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "124--149",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102808.html",
  abstract =     "A {\em wait-free\/} implementation of a concurrent
                 data object is one that guarantees that any process can
                 complete any operation in a finite number of steps,
                 regardless of the execution speeds of the other
                 processes. The problem of constructing a wait-free
                 implementation of one data object from another lies at
                 the heart of much recent work in concurrent algorithms,
                 concurrent data structures, and multiprocessor
                 architectures. First, we introduce a simple and general
                 technique, based on reduction to a concensus protocol,
                 for proving statements of the form, ``there is no
                 wait-free implementation of $X$ by $Y$.'' We derive a
                 hierarchy of objects such that no object at one level
                 has a wait-free implementation in terms of objects at
                 lower levels. In particular, we show that atomic
                 read/write registers, which have been the focus of much
                 recent attention, are at the bottom of the hierarchy:
                 they cannot be used to construct wait-free
                 implementations of many simple and familiar data types.
                 Moreover, classical synchronization primitives such as
                 {\em test\&set\/} and {\em fetch\&add}, while more
                 powerful than {\em read\/} and {\em write}, are also
                 computationally weak, as are the standard
                 message-passing primitives. Second, nevertheless, we
                 show that there do exist simple universal objects from
                 which one can construct a wait-free implementation of
                 any sequential object.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; reliability; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Synchronization. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Concurrency.",
}

@Article{Ancona:1991:ECL,
  author =       "M. Ancona and G. Dodero and V. Gianuzzi and M.
                 Morgavi",
  title =        "Efficient Construction of {LR$ (k) $} States and
                 Tables",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "150--178",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/102809.html",
  abstract =     "A new method for building LR($k$) states and parsing
                 tables is presented. The method aims at giving a
                 feasible construction of a collection of LR($k$)
                 parsing tables, especially when $ k > 1$. for
                 nontrivial grammars. To this purpose, the algorithm
                 first attempts to build a set of {\em normal states\/}
                 for the given grammar, each one associated to a single
                 parsing action in {\em accept, reduce, shift}. When
                 such an action cannot be uniquely determined, that is,
                 when up to $k$ input symbols have to be examined
                 (inadequacy), further states, belonging to a new type,
                 called {\em look-ahead\/} states, are computed. The
                 action associated with inadequate states is a new
                 parsing action, {\em look}. States are built without
                 actual computation of the FIRST${}_k$ and EFF${}_k$
                 functions; that is, nonterminals are kept in the
                 context string of items composing each state, and their
                 expansion to terminals is deferred until indispensable
                 to solve inadequacy. The aforementioned method is
                 illustrated; then the canonical collection of states
                 and the canonical tables are compared with those
                 obtained from the proposed method. A sufficient
                 condition is stated, by which the size of parsing
                 tables, obtained by applying this new method, is
                 smaller than that of canonical tables. Experimental
                 results show that such a condition is verified by the
                 grammars of several programming languages and that
                 significant speed is gained by avoiding the computation
                 of the FIRST${}_k$ function.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; languages; theory;
                 verification",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types.",
}

@Article{Wileden:1991:CCE,
  author =       "Jack C. Wileden and Lori A. Clarke and Alexander L.
                 Wolf",
  title =        "Corrigenda: ``{A Comparative Evaluation of Object
                 Definition Techniques for Large Prototype Systems}''",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "1",
  pages =        "179--179",
  month =        jan,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Wileden:1990:CEO}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wegman:1991:CPC,
  author =       "Mark N. Wegman and F. Kenneth Zadeck",
  title =        "Constant Propagation with Conditional Branches",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "2",
  pages =        "181--210",
  month =        apr,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/103136.html",
  abstract =     "Constant propagation is a well-known global flow
                 analysis problem. The goal of constant propagation is
                 to discover values that are constant on all possible
                 executions of a program and to propagate these constant
                 values as far forward through the program as possible.
                 Expressions whose operands are all constants can be
                 evaluated at compile time and the results propagated
                 further. Using the algorithms presented in this paper
                 can produce smaller and faster compiled programs. The
                 same algorithms can be used for other kinds of analyses
                 (e.g., type of determination). We present four
                 algorithms in this paper, all {\em conservative\/} in
                 the sense that all constants may not be found, but each
                 constant found is constant over all possible executions
                 of the program. These algorithms are among the
                 simplest, fastest, and most powerful global constant
                 propagation algorithms known. We also present a new
                 algorithm that performs a form of interprocedural data
                 flow analysis in which aliasing information is gathered
                 in conjunction with constant progagation. Several
                 variants of this algorithm are considered.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features.",
}

@Article{Yellin:1991:ILI,
  author =       "Daniel M. Yellin and Robert E. Strom",
  title =        "{INC}: a Language for Incremental Computations",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "2",
  pages =        "211--236",
  month =        apr,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/103137.html",
  abstract =     "An incremental computation is one that is performed
                 repeatedly on nearly identical inputs. Incremental
                 computations occur naturally in many environments, such
                 as compilers, language-based editors, spreadsheets, and
                 formatters. This article describes a proposed tool for
                 making it easy to write incremental programs. The tool
                 consists of a programming language, INC, and a set of
                 compile-time transformations for the primitive elements
                 of INC. A programmer defines an algorithm in INC
                 without regard to efficient incremental execution. The
                 transformations automatically convert this algorithm
                 into an efficient incremental algorithm. INC is a
                 functional language. The implementation of an INC
                 program is a network of processes. Each INC function is
                 transformed into a process that receives and transmits
                 messages describing changes to its inputs and outputs.
                 We give an overview to the language and illustrate the
                 incremental techniques employed by INC. We present the
                 static and incremental complexity bounds for the
                 primitive INC functions. We also present some example
                 programs illustrating INC's flexibility.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, INC. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.2.6}: Software, SOFTWARE ENGINEERING, Programming
                 Environments, Interactive.",
}

@Article{Abadi:1991:DTS,
  author =       "Mart{\'\i}n Abadi and Luca Cardelli and Benjamin
                 Pierce and Gordon Plotkin",
  title =        "Dynamic Typing in a Statically Typed Language",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "2",
  pages =        "237--268",
  month =        apr,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/103138.html",
  abstract =     "Statically typed programming languages allow earlier
                 error checking, better enforcement of disciplined
                 programming styles, and the generation of more
                 efficient object code than languages where all type
                 consistency checks are performed at run time. However,
                 even in statically typed languages, there is often the
                 need to deal with data whose type cannot be determined
                 at compile time. To handle such situations safely, we
                 propose to add a type Dynamic whose values are pairs of
                 a value $v$ and a type tag $T$ where $v$ has the type
                 denoted by $T$. Instances of Dynamic are built with an
                 explicit tagging construct and inspected with a type
                 safe typecase construct.\par

                 This paper explores the syntax, operational semantics,
                 and denotational semantics of a simple language that
                 includes the type Dynamic. We give examples of how
                 dynamically typed values can be used in programming.
                 Then we discuss an operational semantics for our
                 language and obtain a soundness theorem. We present two
                 formulations of the denotational semantics of this
                 language and relate them to the operational semantics.
                 Finally, we consider the implications of polymorphism
                 and some implementation issues.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf F.3.2}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Semantics of
                 Programming Languages.",
}

@Article{Hudak:1991:CIE,
  author =       "Paul Hudak and Jonathan Young",
  title =        "Collecting Interpretations of Expressions",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "2",
  pages =        "269--290",
  month =        apr,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/103139.html",
  abstract =     "A {\em collecting interpretation of expressions\/} is
                 an interpretation of a program that allows one to
                 answer questions of the sort: ``What are all possible
                 values to which an expression might evaluate during
                 program execution?'' Answering such questions in a
                 denotational framework is akin to traditional data flow
                 analysis and, when used in the context of abstract
                 interpretation, allows one to infer properties that
                 approximate the run-time behavior of expression
                 evaluation.\par

                 Exact collecting interpretations of expressions are
                 developed for three abstract functional languages: a
                 strict first-order language, a nonstrict first-order
                 language, and a nonstrict higher order language (the
                 full untyped lambda calculus with constants). It is
                 argued that the method is simple (in particular, no
                 powerdomains are needed), Natural (it captures the
                 intuitive operational behavior of a cache), yet more
                 expressive than existing methods (it is the first exact
                 collecting interpretation for either nonstrict higher
                 order languages). Correctness of the interpretations
                 with respect to the standard semantics is shown via a
                 generalization of the notion of strictness. It is
                 further shown how to form abstractions of these exact
                 interpretations, using as an example a collecting
                 strictness analysis which yields compile-time
                 information not previously captured by conventional
                 strictness analyses.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf F.4.2}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Grammars and Other Rewriting Systems. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Dhamdhere:1991:PAG,
  author =       "Dhananjay M. Dhamdhere",
  title =        "Practical Adaptation of the Global Optimization
                 Algorithm of {Morel} and {Renvoise}",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "2",
  pages =        "291--294",
  month =        apr,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/103161.html;
                 http://www.acm.org/pubs/toc/Abstracts/0164-0925/214520.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Borstler:1991:TCT,
  author =       "J{\"u}rgen B{\"o}rstler and Ulrich M{\"o}ncke and
                 Reinhard Wilhelm",
  title =        "Table Compression for Tree Automata",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "295--314",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/117013.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation; theory",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf F.1.1}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Models of Computation,
                 Automata. {\bf E.1}: Data, DATA STRUCTURES, Trees. {\bf
                 E.4}: Data, CODING AND INFORMATION THEORY, Data
                 compaction and compression.",
}

@Article{Hudson:1991:IAE,
  author =       "Scott E. Hudson",
  title =        "Incremental Attribute Evaluation: a Flexible Algorithm
                 for Lazy Update",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "315--341",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/117012.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf I.1.3}: Computing Methodologies, ALGEBRAIC
                 MANIPULATION, Languages and Systems, Evaluation
                 strategies. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf I.1.2}: Computing Methodologies,
                 ALGEBRAIC MANIPULATION, Algorithms, Nonalgebraic
                 algorithms.",
}

@Article{Morrison:1991:AHA,
  author =       "R. Morrison and A. Dearle and R. C. H. Connor and A.
                 L. Brown",
  title =        "An Ad Hoc Approach to the Implementation of
                 Polymorphism",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "342--371",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/117017.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Napier88. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Run-time environments. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Abstract data types.",
}

@Article{Murtagh:1991:ISM,
  author =       "Thomas P. Murtagh",
  title =        "An Improved Storage Management Scheme for Block
                 Structured Languages",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "372--398",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/117016.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Structured programming. {\bf G.2.2}:
                 Mathematics of Computing, DISCRETE MATHEMATICS, Graph
                 Theory, Graph algorithms.",
}

@Article{Peng:1991:DFA,
  author =       "Wuxu Peng and S. Purushothaman",
  title =        "Data Flow Analysis of Communicating Finite State
                 Machines",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "399--442",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  note =         "See \cite{Purushothaman:1991:CDF}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/117015.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory; verification",
  subject =      "{\bf F.1.1}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Models of Computation,
                 Unbounded-action devices. {\bf F.2.2}: Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems,
                 Sequencing and scheduling. {\bf F.1.1}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Models of
                 Computation, Automata.",
}

@Article{Krogh:1991:AAP,
  author =       "Fred T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "443--446",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Misc/IMMD_IV.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1991:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "3",
  pages =        "447--450",
  month =        jul,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:07:30 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cytron:1991:ECS,
  author =       "Ron Cytron and Jeanne Ferrante and Barry K. Rosen and
                 Mark N. Wegman and F. Kenneth Zadeck",
  title =        "Efficiently Computing Static Single Assignment Form
                 and the Control Dependence Graph",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "451--490",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115320.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 I.1.2}: Computing Methodologies, ALGEBRAIC
                 MANIPULATION, Algorithms, Analysis of algorithms. {\bf
                 I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation.",
}

@Article{Choi:1991:TDP,
  author =       "Jong-Deok Choi and Barton P. Miller and Robert H. B.
                 Netzer",
  title =        "Techniques for Debugging Parallel Programs with
                 Flowback Analysis",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "491--530",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Ooos.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115324.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; measurement;
                 performance",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.2.5}: Software,
                 SOFTWARE ENGINEERING, Testing and Debugging, Monitors.
                 {\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Tracing. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Procedures, functions, and
                 subroutines. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Code generation. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Multiprocessing/multiprogramming. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming, Parallel programming.",
}

@Article{Sheard:1991:AGU,
  author =       "Tim Sheard",
  title =        "Automatic Generation and Use of Abstract Structure
                 Operators",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "531--557",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115369.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Recursion. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming.",
}

@Article{Lycklama:1991:FCF,
  author =       "Edward A. Lycklama and Vassos Hadzilacos",
  title =        "A First-Come-First-Served Mutual-Exclusion Algorithm
                 with Small Communication Variables",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "558--576",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115370.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; theory",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Mutual exclusion. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Synchronization.
                 {\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems.",
}

@Article{Jagadeesan:1991:FAS,
  author =       "Radha Jagadeesan and Keshav Pingali and Prakash
                 Panangaden",
  title =        "A Fully Abstract Semantics for a First-Order
                 Functional Language with Logic Variables",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "577--625",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115371.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Logic programming. {\bf
                 D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming.",
}

@Article{Cohen:1991:TCT,
  author =       "Norman H. Cohen",
  title =        "Technical Correspondence: Type-Extension Type Tests
                 Can Be Performed In Constant Time",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "626--629",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 14:08:14 1996",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/w/wirth-niklaus.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Wirth:1988:TE,Wirth:1991:TCR}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/115297.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Procedures, functions, and
                 subroutines. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors. {\bf E.2}: Data, DATA STORAGE
                 REPRESENTATIONS, Linked representations. {\bf E.1}:
                 Data, DATA STRUCTURES, Lists.",
}

@Article{Wirth:1991:TCR,
  author =       "Niklaus Wirth",
  title =        "Technical Correspondence: Reply to ``{Type}-Extension
                 Tests Can Be Performed In Constant Time''",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "630--630",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 08:25:24 2024",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/w/wirth-niklaus.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Wirth:1988:TE,Cohen:1991:TCT}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214521.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  author-dates = "Niklaus Wirth (15 February 1934--1 January 2024)",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "performance",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.",
}

@Article{Volpano:1991:TCS,
  author =       "Dennis M. Volpano",
  title =        "Technical Correspondence: Subtypes and
                 Quantification",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "631--632",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Burton:1990:TCT,Burton:1991:TCA}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214523.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure.",
}

@Article{Burton:1991:TCA,
  author =       "F. Warren Burton",
  title =        "Technical Correspondence: Author's Reply to
                 ``{Subtypes and Quantification}'', by {D. M. Volpano}",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "633--633",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 6 14:12:08 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Burton:1990:TCT,Volpano:1991:TCS}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Purushothaman:1991:CDF,
  author =       "S. Purushothaman",
  title =        "Corrigendum: ``{Data Flow Analysis of Communicating
                 Finite State Machines}''",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "633--633",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Peng:1991:DFA}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1991:AI,
  author =       "Anonymous",
  title =        "1991 Author Index",
  journal =      j-TOPLAS,
  volume =       "13",
  number =       "4",
  pages =        "634--635",
  month =        oct,
  year =         "1991",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:14:37 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ungar:1992:ATP,
  author =       "David Ungar and Frank Jackson",
  title =        "An Adaptive Tenuring Policy for Generation
                 Scavengers",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "1",
  pages =        "1--27",
  month =        jan,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/116734.html",
  abstract =     "One of the more promising automatic storage
                 reclamation techniques, generation scavenging, suffers
                 poor performance if many objects live for a fairly long
                 time and then die. We have investigated the severity of
                 this problem by simulating a two-generation scavenger
                 using traces taken from actual 4-h sessions. There was
                 a wide variation in the sample runs, with
                 garbage-collection overhead ranging from insignificant,
                 during three of the runs, to severe, during a single
                 run. All runs demonstrated that performance could be
                 improved with two techniques: segregating large bitmaps
                 and strings, and adapting the scavenger's tenuring
                 policy according to demographic feedback. We therefore
                 incorporated these ideas into a commercial Smalltalk
                 implementation. These two improvements deserve
                 consideration for any storage reclamation strategy that
                 utilizes a generation scavenger.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; measurement; performance;
                 theory",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Allocation/deallocation strategies. {\bf
                 D.2.6}: Software, SOFTWARE ENGINEERING, Programming
                 Environments, Interactive. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications, Self.
                 {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Smalltalk. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Run-time
                 environments.",
}

@Article{Solworth:1992:E,
  author =       "Jon A. Solworth",
  title =        "Epochs",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "1",
  pages =        "28--53",
  month =        jan,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/116785.html",
  abstract =     "To date, the implementation of message passing
                 languages has required the communications variables
                 (sometimes called ports) either to be limited to the
                 number of physical communications registers in the
                 machine or to be mapped to memory. Neither solution is
                 satisfactory. Limiting the number of variables
                 decreases modularity and efficiency of parallel
                 programs. Mapping variables to memory increases the
                 cost of communications and the granularity of
                 parallelism. We present here a new programming language
                 construct called {\em epochs}.\par

                 Epochs are a scoping mechanism within which the
                 programmer can declare communications variables, which
                 are live only during the scope of that epoch. To limit
                 the range of time a register has to be allocated for a
                 communications variable, the compiler ensures that all
                 processors enter an epoch simultaneously. The
                 programming style engendered fits somewhere between the
                 SIMD data parallel and the MIMD process spawning
                 models.\par

                 We describe an implementation for epochs including an
                 efficient synchronization mechanism, a means of
                 statically binding registers to communications
                 variables, and a method of fusing epochs to reduce
                 synchronization overhead.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf D.4.4}: Software,
                 OPERATING SYSTEMS, Communications Management, Message
                 sending. {\bf C.1.2}: Computer Systems Organization,
                 PROCESSOR ARCHITECTURES, Multiple Data Stream
                 Architectures (Multiprocessors). {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Synchronization.",
}

@Article{Hickey:1992:CAM,
  author =       "Timothy J. Hickey and Jacques Cohen and Hitofumi Hotta
                 and Thierry PetitJean",
  title =        "Computer-Assisted Microanalysis of Parallel Programs",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "1",
  pages =        "54--106",
  month =        jan,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/126699.html",
  abstract =     "This paper consists of two parts: the first provides
                 the theoretical foundations for analyzing parallel
                 programs and illustrates how the theory can be applied
                 to estimate the execution time of a class of parallel
                 programs being executed on a MIMD computer. The second
                 part describes a program analysis system, based on the
                 theoretical model, which allows a user to interactively
                 analyze the results of executing (or simulating the
                 execution) of such parallel programs. Several examples
                 illustrating the use of the tool are presented. A novel
                 contribution is the separation (both at the conceptual
                 and the implementation levels) of the
                 machine-independent and the machine-dependent parts of
                 the analysis. This separation enables the users of the
                 system to establish speed-up curves for machines having
                 varying characteristics.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance; theory",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Parallel programming. {\bf
                 D.2.8}: Software, SOFTWARE ENGINEERING, Metrics,
                 Performance measures. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Programmer
                 workbench. {\bf D.2.5}: Software, SOFTWARE ENGINEERING,
                 Testing and Debugging, Symbolic execution. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Prolog.",
}

@Article{Gudeman:1992:DSG,
  author =       "David A. Gudeman",
  title =        "Denotational Semantics of a Goal-Directed Language",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "1",
  pages =        "107--125",
  month =        jan,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/104659.html",
  abstract =     "Goal-directed evaluation is a very expressive
                 programming language paradigm that is supported in
                 relatively few languages. It is characterized by
                 evaluation of expressions in an attempt to meet some
                 goal, with resumption of previous expressions on
                 failure. This paradigm is found in SNOBL4 in its
                 pattern-matching facilities, and in Icon as a general
                 part of the language. This paper presents a
                 denotational semantics of Icon and shows how Icon is in
                 fact a combination of two distinct paradigms,
                 goal-directed evaluation and functional application.
                 The two paradigms are not supported separately in
                 different contexts, but integrated fully into a single
                 evaluation mechanism.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Nonprocedural
                 languages. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, ICON. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Control structures. {\bf F.3.3}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs, Control primitives.",
}

@Article{Boute:1992:EDF,
  author =       "Raymond T. Boute",
  title =        "The {Euclidean} Definition of the Functions div and
                 mod",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "127--144",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128862.html",
  abstract =     "The definitions of the functions div and mod in the
                 computer science literature and in programming
                 languages are either similar to the Algol of Pascal
                 definition (which is shown to be an unfortunate choice)
                 or based on division by truncation (T-definition) or
                 division by flooring as defined by Knuth
                 (F-definition). The differences between various
                 definitions that are in common usage are discussed, and
                 an additional one is proposed, which is based on
                 Euclid's theorem and therefore is called the {\em
                 Euclidean\/} definition (E-definition). Its
                 distinguishing feature is that $ 0 <= D \bmod d < d $
                 irrespective of the signs of $D$ and $d$. It is argued
                 that the E- and F-definitions are superior to all other
                 ones in regularity and useful mathematical properties
                 and hence deserve serious consideration as the standard
                 convention at the applications and language level. It
                 is also shown that these definitions are the most
                 suitable ones for describing number representation
                 systems and the realization of arithmetic operations at
                 the architecture and hardware level.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; standardization; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf B.2.m}:
                 Hardware, ARITHMETIC AND LOGIC STRUCTURES,
                 Miscellaneous. {\bf D.3.0}: Software, PROGRAMMING
                 LANGUAGES, General, Standards. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Data types and structures. {\bf G.1.0}:
                 Mathematics of Computing, NUMERICAL ANALYSIS, General,
                 Computer arithmetic.",
}

@Article{Wolf:1992:GEI,
  author =       "Alexander L. Wolf",
  title =        "{Guest Editor}'s Introduction to the Special Section
                 on the {Third International Conference on Computer
                 Languages}",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "145--146",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 11:18:44 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128863.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "{\bf D.3.0}: Software, PROGRAMMING LANGUAGES, General.
                 {\bf F.3.0}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, General. {\bf F.4.0}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 General.",
}

@Article{Gomard:1992:SAP,
  author =       "Carsten K. Gomard",
  title =        "A Self-applicable Partial Evaluator for the Lambda
                 Calculus: Correctness and Pragmatics",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "147--172",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/absint.bib; Compiler/Compiler.Lins.bib;
                 Compiler/partial-eval.bib; Compiler/semantics.bib;
                 Compiler/TOPLAS.bib; Compiler/TOPPS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/partial-eval.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128864.html",
  abstract =     "We describe theoretical and a few practical aspects of
                 an implemented self-applicable partial evaluator for
                 the untyped lambda calculus with constants,
                 conditionals, and a fixed point operator.\par

                 The purpose of this paper is first to announce the
                 existence of (and to describe) a partial evaluator that
                 is both higher-order and self-applicable; second to
                 describe a surprisingly simple solution to the central
                 problem of binding time analysis, and third to prove
                 that the partial evaluator yields correct
                 answers.\par

                 While [lambda]-mix (the name of our system) seems to
                 have been the first higher-order self-applicable
                 partial evaluator to run on a computer, it was
                 developed mainly for research purposes. Two recently
                 developed systems are much more powerful for practical
                 use, but also much more complex: Similix[3,5] and
                 Schism[7].\par

                 Our partial evaluator is surprisingly simple,
                 completely automatic, and has been implemented in a
                 side effect-free subset of Scheme. It has been used to
                 compile, generate compilers and generate a compiler
                 generator.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "correctness; lambda calculus; languages; partial
                 evaluation; self-application; theory",
  semno =        "D-78",
  subject =      "{\bf I.1.3}: Computing Methodologies, ALGEBRAIC
                 MANIPULATION, Languages and Systems, Evaluation
                 strategies. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Lambda calculus and related systems. {\bf
                 F.3.2}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Translator writing
                 systems and compiler generators. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications.",
  summary =      "A partial evaluator for the Lambda Calculus is
                 described and proven correct. This means that programs
                 generated by the partial evaluator (including, e.g.,
                 the compilers obtained by self-application) are known
                 to be correct.",
}

@Article{Pollock:1992:IGR,
  author =       "Lori L. Pollock and Mary Lou Soffa",
  title =        "Incremental Global Reoptimization of Programs",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "173--200",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128865.html",
  abstract =     "Although optimizing compilers have been quite
                 successful in producing excellent code, two factors
                 that limit their usefulness are the accompanying long
                 compilation times and the lack of good symbolic
                 debuggers for optimized code. One approach to attaining
                 faster recompilations is to reduce the redundant
                 analysis that is performed for optimization in response
                 to edits, and in particulars, small maintenance
                 changes, without affecting the quality of the generated
                 code. Although modular programming with separate
                 compilation aids in eliminating unnecessary
                 recompilation and reoptimization, recent studies have
                 discovered that more efficient code can be generated by
                 collapsing a modular program through procedure
                 inlining. To avoid having to reoptimize the resultant
                 large procedures, this paper presents techniques for
                 incrementally incorporating changes into globally
                 optimized code. An algorithm is given for determining
                 which optimizations are no longer safe after a program
                 change, and for discovering which new optimizations can
                 be performed in order to maintain a high level of
                 optimization. An intermediate representation is
                 incrementally updated to reflect the current
                 optimizations in the program. Analysis is performed in
                 response to changes rather than in preparation for
                 possible changes, so analysis is not wasted if an edit
                 has no far-reaching effects. The techniques developed
                 in this paper have also been exploited to improve on
                 the current techniques for symbolic debugging of
                 optimized code.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques.",
}

@Article{Kaiser:1992:OBP,
  author =       "Gail E. Kaiser and Brent Hailpern",
  title =        "An Object-Based Programming Model for Shared Data",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "201--264",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128866.html",
  abstract =     "The classical object model supports private data
                 within objects and clean interfaces between objects,
                 and by definition does not permit sharing of data among
                 arbitrary objects. This is a problem for real-world
                 applications, such as advanced financial services and
                 integrated network management, where the same data
                 logically belong to multiple objects and may be
                 distributed over multiple nodes on the network. Rather
                 than give up the advantages of encapsulated objects in
                 modeling real-world entities, we propose a new object
                 model that supports shared data in a distributed
                 environment. The key is separating distribution of
                 computation units from information-hiding concerns.
                 Minimal units of data and control, called {\em facets},
                 may be shared among multiple {\em objects\/} and are
                 grouped into {\em processes}. Thus, a single object, or
                 information-hiding unit, may be distributed among
                 multiple processes, or computation units. In other
                 words, different facets of the same object may reside
                 in different address spaces on different machines. We
                 introduce our new object model, describe a motivating
                 example from the financial domain, and then explain
                 facets, objects, and processes, followed by timing and
                 synchronization concerns.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Distributed programming. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages. {\bf H.2.4}: Information Systems, DATABASE
                 MANAGEMENT, Systems, Distributed systems. {\bf E.2}:
                 Data, DATA STORAGE REPRESENTATIONS. {\bf E.1}: Data,
                 DATA STRUCTURES.",
}

@Article{Koopman:1992:CBC,
  author =       "Philip J. {Koopman, Jr.} and Peter Lee and Daniel P.
                 Siewiorek",
  title =        "Cache Behavior of Combinator Graph Reduction",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "2",
  pages =        "265--297",
  month =        apr,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:28:31 1996",
  bibsource =    "Compiler/Compiler.Lins.bib;
                 Compiler/garbage.collection.bib; Compiler/Heaps.bib;
                 Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/CLiCS.bib",
  note =         "Also see~\cite{Koopman:1992:CBC}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/128867.html",
  abstract =     "The results of cache-simulation experiments with an
                 abstract machine for reducing combinator graphs are
                 presented. The abstract machine, called TIGRE, exhibits
                 reduction rates that, for similar kinds of combinator
                 graphs on similar kinds of hardware, compare favorably
                 with previously reported techniques. Furthermore, TIGRE
                 maps easily and efficiently onto standard computer
                 architectures, particularly those that allow a
                 restricted form of self-modifying code. This provides
                 some indication that the conventional ``stored
                 program'' organization of computer systems is not
                 necessarily an inappropriate one for functional
                 programming language implementations.\par

                 This is not to say, however, that present day computer
                 systems are well equipped to reduce combinator graphs.
                 In particular, the behavior of the cache memory has a
                 significant effect on performance. In order to study
                 and quantify this effect, trace-driven cache
                 simulations of a TIGRE graph reducer running on a
                 reduced instruction-set computer are conducted. The
                 results of these simulations are presented with the
                 following hardware-cache parameters varied: cache size,
                 block size, associativity, memory update policy, and
                 write-allocation policy. To begin with, the cache
                 organization of a commercially available system is used
                 and then the performance sensitivity with respect to
                 variations of each parameter are measured. From the
                 results of the simulation study, a conclusion is made
                 that combinator-graph reduction using TIGRE runs most
                 efficiently when using a cache memory with an
                 allocate-on-write-miss strategy, moderately large block
                 size (preferably with subblock placement), and
                 copy-back memory updates.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory;
                 threading",
  sjb =          "In amongst all the cache stuff is a description of how
                 subroutine threading can form the basis for a
                 relatively efficient method of performing combinator
                 graph reduction.",
  subject =      "{\bf B.3.2}: Hardware, MEMORY STRUCTURES, Design
                 Styles, Cache memories. {\bf B.3.3}: Hardware, MEMORY
                 STRUCTURES, Performance Analysis and Design Aids,
                 Simulation. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Interpreters. {\bf G.2.1}: Mathematics of
                 Computing, DISCRETE MATHEMATICS, Combinatorics.",
}

@Article{Wall:1992:ESD,
  author =       "David W. Wall",
  title =        "Experience with a Software-Defined Machine
                 Architecture",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "299--338",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/129395.html",
  abstract =     "We have built a system in which the compiler back end
                 and the linker work together to present an abstract
                 machine at a considerably higher level than the actual
                 machine. The intermediate language translated by the
                 back end is the target language of all high-level
                 compilers and is also the only assembly language
                 generally available. This lets us do intermodule
                 register allocation, which would be harder if some of
                 the code in the program had come from a traditional
                 assembler, out of sight of the optimizer. We do
                 intermodule register allocation and pipeline
                 instruction scheduling at link time, using information
                 gathered by the compiler back end. The mechanism for
                 analyzing and modifying the program at link time is
                 also useful in a wide array of instrumentation tools.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 C.0}: Computer Systems Organization, GENERAL,
                 Instruction set design. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications, Macro
                 and assembly languages.",
}

@Article{Jaffar:1992:CLS,
  author =       "Joxan Jaffar and Spiro Michaylov and Peter J. Stuckey
                 and Roland H. C. Yap",
  title =        "The {CLP($ \cal R$)} Language and System",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "339--395",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/129398.html",
  abstract =     "The CLP $ (R) $ programming language is defined, its
                 underlying philosophy and programming methodology are
                 discussed, important implementation issues are explored
                 in detail, and finally, a prototype interpreter is
                 described.\par

                 CLP $ (R) $ is designed to be an instance of the
                 Constraint Logic Programming Scheme, a family of
                 rule-based constraint programming languages defined by
                 Jaffar and Lassez. The domain of computation $R$ of
                 this particular instance is the algebraic structure
                 consisting of uninterpreted functors over real numbers.
                 An important property of CLP $ (R) $ is that the
                 constraints are treated uniformly in the sense that
                 they are used to specify the input parameters to a
                 program, they are the only primitives used in the
                 execution of a program, and they are used to describe
                 the output of a program.\par

                 Implementation of a CLP language, and of CLP $ (R) $ in
                 particular, raises new problems in the design of a
                 constraint-solver. For example, the constraint solver
                 must be incremental in the sense that solving
                 additional constraints must not entail the resolving of
                 old constraints. In our system, constraints are
                 filtered through an inference engine, an engine/solver
                 interface, an equation solver and an inequality solver.
                 This sequence of modules reflects a classification and
                 prioritization of the classes of constraints. Modules
                 solving higher priority constraints are isolated from
                 the complexities of modules solving lower priority
                 constraints. This multiple-phase solving of
                 constraints, together with a set of associated
                 algorithms, gives rise to a practical system.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.m}: Software, PROGRAMMING LANGUAGES,
                 Miscellaneous. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Interpreters. {\bf G.1.3}:
                 Mathematics of Computing, NUMERICAL ANALYSIS, Numerical
                 Linear Algebra, Linear systems (direct and iterative
                 methods). {\bf I.1.3}: Computing Methodologies,
                 ALGEBRAIC MANIPULATION, Languages and Systems. {\bf
                 D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf F.4.0}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, General.",
}

@Article{Widom:1992:TBN,
  author =       "Jennifer Widom and David Gries and F. B. Schneider",
  title =        "Trace-Based Network Proof Systems: Expressiveness and
                 Completeness",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "396--416",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See corrigendum \cite{Widom:1993:CTB}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/129396.html",
  abstract =     "We consider incomplete trace-based network proof
                 systems for safety properties, identifying extensions
                 that are necessary and sufficient to achieve relative
                 completeness. We investigate the expressiveness
                 required of any trace logic to encode these
                 extensions.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf F.3.1}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Proof theory.",
}

@Article{Shankar:1992:SRH,
  author =       "A. Udaya Shankar and Simon S. Lam",
  title =        "A Stepwise Refinement Heuristic for Protocol
                 Construction",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "417--461",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/Compiler.Lins.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/129394.html",
  abstract =     "A stepwise refinement heuristic to construct
                 distributed systems is presented. The heuristic is
                 based on a conditional refinement relation between
                 system specifications, and a ``Marking''. It is applied
                 to construct four sliding window protocols that provide
                 reliable data transfer over unreliable communication
                 channels. The protocols use modulo-$N$ sequence
                 numbers. The first protocol is for channels that can
                 only lose messages in transit. By refining this
                 protocol, we obtain three protocols for channels that
                 can lose, reorder, and duplicate messages in transit.
                 The protocols herein are less restrictive and easier to
                 implement than sliding window protocols previously
                 studied in the protocol verification literature.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; verification",
  subject =      "{\bf C.2.2}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Protocols,
                 Protocol verification. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Krogh:1992:AAP,
  author =       "Fred T. Krogh",
  title =        "{ACM} Algorithms Policy",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "462--465",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:1992:IA,
  author =       "Anonymous",
  title =        "Information for Authors",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "3",
  pages =        "466--469",
  month =        jul,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:15:24 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hansen:1992:SRF,
  author =       "Wilfred J. Hansen",
  title =        "Subsequence References: First-Class Values for
                 Substrings",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "471--489",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/133234.html",
  abstract =     "Arrays of characters are a basic data type in many
                 programming languages, but strings and substrings are
                 seldom accorded first-class status as parameters and
                 return values. Such status would enable a routine that
                 calls a search function to readily access context on
                 both sides of a return value. To enfranchise
                 substrings, this paper describes a new data type for
                 substrings as a special case of one for general
                 subsequences. The key idea is that values are not
                 sequences or references to positions in sequences, but
                 rather references to subsequences. Primitive operations
                 on the data type are constants, concatenation, and four
                 new functions --- {\em base}, {\em start}, {\em next},
                 and {\em extent\/} --- which map subsequence references
                 to subsequence references.\par

                 This paper informally presents the data type,
                 demonstrates its convenience for defining search
                 functions, and shows how it can be concisely
                 implemented. Examples are given in Ness, a language
                 incorporating the new data type, which is implemented
                 as part of the Andrew User Interface System.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf E.1}: Data, DATA STRUCTURES.",
}

@Article{Heering:1992:IGL,
  author =       "J. Heering and P. Klint and J. Rekers",
  title =        "Incremental Generation of Lexical Scanners",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "490--520",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/133240.html",
  abstract =     "It is common practice to specify textual patterns by
                 means of a set of regular expressions and to transform
                 this set into a finite automaton to be used for the
                 scanning of input strings. In many applications, the
                 cost of this preprocessing phase can be amortized over
                 many uses of the constructed automaton. In this paper
                 new techniques for lazy and incremental scanner
                 generation are presented. The lazy technique postpones
                 the construction of parts of the automaton until they
                 are really needed during the scanning of input. The
                 incremental technique allows modifications to the
                 original set of regular expressions to be made and
                 reuses major parts of the previous automaton. This is
                 interesting in applications such as environments for
                 the interactive development of language definitions in
                 which modifications to the definition of lexical syntax
                 and the uses of the generated scanners alternate
                 frequently.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.1.2}: Software, PROGRAMMING TECHNIQUES,
                 Automatic Programming. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Translator writing
                 systems and compiler generators.",
}

@Article{Morzenti:1992:MPR,
  author =       "Angelo Morzenti and Dino Mandrioli and Carlo Ghezzi",
  title =        "A Model Parametric Real-Time Logic",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "521--573",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/129397.html",
  abstract =     "TRIO is a formal notation for the logic-based
                 specification of real-time systems. In this paper the
                 language and its straightforward model-theoretic
                 semantics are briefly summarized. Then the need for
                 assigning a consistent meaning to TRIO specifications
                 is discussed, with reference to a variety of underlying
                 time structures such as infinite-time structures (both
                 dense and discrete) and finite-time structures. The
                 main motivation is the ability to validate formal
                 specifications. A solution to this problem is
                 presented, which gives a new, model-parametric
                 semantics to the language. An algorithm for
                 constructively verifying the satisfiability of formulas
                 in the decidable cases is defined, and several
                 important temporal properties of specifications are
                 characterized.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Languages. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Model theory. {\bf
                 D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Tools. {\bf D.4.7}:
                 Software, OPERATING SYSTEMS, Organization and Design,
                 Real-time and embedded systems.",
}

@Article{Katzenelson:1992:TMT,
  author =       "Jacob Katzenelson and Shlomit S. Pinter and Eugen
                 Schenfeld",
  title =        "Type Matching, Type-Graphs, and the {Schanuel}
                 Conjecture",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "574--588",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/133247.html",
  abstract =     "This work considers type systems that are defined by
                 type-graphs (tgraphs), which are rooted directed graphs
                 with order among the edges leaving each node. Tgraphs
                 are uniquely mapped into polynomials which, in turn,
                 are each evaluated at a special point to yield an
                 irrational number named the tgraph's {\em magic
                 number}. This special point is chosen using the
                 Schanuel conjecture. It is shown that each tgraph can
                 be uniquely represented by this magic number; namely,
                 types are equal if and only if the corresponding magic
                 numbers are equal. Since irrational numbers require
                 infinite precision, the algorithm for generating magic
                 numbers is carried out using a double-precision
                 floating-point approximation. This approximation is
                 viewed as a hashing scheme, mapping the infinite domain
                 of the irrational numbers into finite computer words.
                 The proposed hashing scheme was investigated
                 experimentally, with the conclusion that it is a good
                 and practical hashing method. In tests involving over a
                 million randomly chosen tgraphs, we have not
                 encountered a single collision. We conclude that this
                 method for representation and management of types is
                 practical, and offers novel possibilities for enforcing
                 strict type matching at link time among separately
                 compiled modules.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf E.2}: Data, DATA STORAGE REPRESENTATIONS,
                 Composite structures. {\bf I.1.1}: Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Expressions and
                 Their Representation, Representations (general and
                 polynomial). {\bf G.2.2}: Mathematics of Computing,
                 DISCRETE MATHEMATICS, Graph Theory. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors.",
}

@Article{Muller:1992:MLR,
  author =       "Robert Muller",
  title =        "{M-LISP}: a Representation-Independent Dialect of
                 {LISP} with Reduction Semantics",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "589--616",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/133254.html",
  abstract =     "In this paper we introduce M-LISP, a dialect of LISP
                 designed with an eye toward reconciling LISP's
                 metalinguistic power with the {\em structural\/} style
                 of operational semantics advocated by Plotkin [28]. We
                 begin by reviewing the original definition of LISP [20]
                 in an attempt to clarify the source of its
                 metalinguistic power. We find that it arises from a
                 problematic clause in this definition. We then define
                 the abstract syntax and operational semantics of
                 M-LISP, essentially a hybrid of M-expression LISP and
                 Scheme. Next, we tie the operational semantics to the
                 corresponding equational logic. As usual, provable
                 equality in the logic implies operational
                 equality.\par

                 Having established this framework we then extend M-LISP
                 with the metalinguistic {\em eval\/} and {\em reify\/}
                 operators (the latter is a nonstrict operator that
                 converts its argument to its metalanguage
                 representation). These operators encapsulate the
                 matalinguistic representation conversions that occur
                 globally in S-expression LISP. We show that the naive
                 versions of these operators render LISP's equational
                 logic inconsistent. On the positive side, we show that
                 a naturally restricted form of the {\em eval\/}
                 operator is confluent and therefore a conservative
                 extension of M-LISP. Unfortunately, we must weaken the
                 logic considerably to obtain a consistent theory of
                 reification.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Operational semantics. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, LISP. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors. {\bf F.3.3}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic, Lambda calculus and related
                 systems.",
}

@Article{Anonymous:1992:AI,
  author =       "Anonymous",
  title =        "1992 Author Index",
  journal =      j-TOPLAS,
  volume =       "14",
  number =       "4",
  pages =        "617--618",
  month =        oct,
  year =         "1992",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:00:28 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tel:1993:DDT,
  author =       "Gerard Tel and Friedmann Mattern",
  title =        "The Derivation of Distributed Termination Detection
                 Algorithms from Garbage Collection Schemes",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "1--35",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/garbage.collection.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Ooos.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151647.html",
  abstract =     "It is shown that the termination detection problem for
                 distributed computations can be modeled as an instance
                 of the garbage collection problem. Consequently,
                 algorithms for the termination detection problem are
                 obtained by applying transformations to garbage
                 collection algorithms. The transformation can be
                 applied to collectors of the ``mark-and-sweep'' type as
                 well as to reference-counting protocol of Lermen and
                 Maurer, the weighted-reference-counting protocol, the
                 local-reference-counting protocol, and Ben-Ari's
                 mark-and-sweep collector into termination detection
                 algorithms. Known termination detection algorithms as
                 well as new variants are obtained.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; theory; verification",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Distributed memories. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification. {\bf C.2.4}:
                 Computer Systems Organization, COMPUTER-COMMUNICATION
                 NETWORKS, Distributed Systems, Network operating
                 systems.",
}

@Article{Cleaveland:1993:CWS,
  author =       "Rance Cleaveland and Joachim Parrow and Bernhard
                 Steffen",
  title =        "The {Concurrency Workbench}: a Semantics-Based Tool
                 for the Verification of Concurrent Systems",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "36--72",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151648.html",
  abstract =     "The Concurrency Workbench is an automated tool for
                 analyzing networks of finite-state processes expressed
                 in Milner's Calculus of Communicating Systems. Its key
                 feature is its breadth: a variety of different
                 verification methods, including equivalence checking,
                 preorder checking, and model checking, are supported
                 for several different process semantics. One experience
                 from our work is that a large number of interesting
                 verification methods can be formulated as combinations
                 of a small number of primitive algorithms. The
                 Workbench has been applied to the verification of
                 communications protocols and mutual exclusion
                 algorithms and has proven a valuable aid in teaching
                 and research.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; reliability; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Specification techniques. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques,
                 Programmer workbench. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification. {\bf C.2.2}:
                 Computer Systems Organization, COMPUTER-COMMUNICATION
                 NETWORKS, Network Protocols, Protocol verification.",
}

@Article{Abadi:1993:CS,
  author =       "Mart{\'\i}n Abadi and Leslie Lamport",
  title =        "Composing Specifications",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "73--132",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib; Database/dbase.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151649.html",
  abstract =     "A rigorous modular specification method requires a
                 proof rule asserting that if each component behaves
                 correctly in isolation, then it behaves correctly in
                 concert with other components. Such a rule is subtle
                 because a component need behave correctly only when its
                 environment does, and each component is part of the
                 others' environments. We examine the precise
                 distinction between a system and its environment, and
                 provide the requisite proof rule when modules are
                 specified with safety and liveness properties.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming.",
}

@Article{Barbuti:1993:GFS,
  author =       "Roberto Barbuti and Roberto Giacobazzi and Giorgio
                 Levi",
  title =        "A General Framework for Semantics-Based Bottom-Up
                 Abstract Interpretation of Logic Programs",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "133--181",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/absint.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151650.html",
  abstract =     "The theory of abstract interpretation provides a
                 formal framework to develop advanced dataflow analysis
                 tools. The idea is to define a nonstandard semantics
                 which is able to compute, in finite time, an
                 approximated model of the program. In this paper, we
                 define an abstract interpretation framework based on a
                 fixpoint approach to the semantics. This leads to the
                 definition, by means of a suitable set of operators, of
                 an abstract fixpoint characterization of a model
                 associated with the program. Thus, we obtain a
                 specializable abstract framework for bottom-up abstract
                 interpretations of definite logic programs. The
                 specialization of the framework is shown on two
                 examples, namely, ground-dependence analysis and
                 depth-$k$ analysis.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages. {\bf
                 D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification. {\bf D.1.6}: Software, PROGRAMMING
                 TECHNIQUES, Logic Programming.",
}

@Article{Afek:1993:LC,
  author =       "Yehuda Afek and Geoffrey Brown and Michael Merritt",
  title =        "Lazy Caching",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "182--205",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Object/Ooos.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151651.html",
  abstract =     "This paper examines cache consistency conditions for
                 multiprocessor shared memory systems. It states and
                 motivates a weaker condition than is normally
                 implemented. An algorithm is presented that exploits
                 the weaker condition to achieve greater concurrency.
                 The algorithm is shown to satisfy the weak consistency
                 condition. Other properties of the algorithm and
                 possible extensions are discussed.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; reliability; verification",
  subject =      "{\bf D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Distributed memories. {\bf B.3.2}:
                 Hardware, MEMORY STRUCTURES, Design Styles, Cache
                 memories. {\bf B.3.2}: Hardware, MEMORY STRUCTURES,
                 Design Styles, Shared memory. {\bf B.3.4}: Hardware,
                 MEMORY STRUCTURES, Reliability, Testing, and
                 Fault-Tolerance.",
}

@Article{Finlay:1993:TCC,
  author =       "Alan Finlay and Lloyd Allison",
  title =        "Technical Correspondence: a Correction to the
                 Denotational Semantics for the {Prolog} of {Nicholson}
                 and {Foo}",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "206--208",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Nicholson:1989:DSP}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/151652.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.4.1}: Theory
                 of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Prolog. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Logic programming. {\bf
                 D.1.1}: Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory.",
}

@Article{Widom:1993:CTB,
  author =       "Jennifer Widom and David Gries and F. B. Schneider",
  title =        "Corrigendum: ``{Trace-Based Network Proof Systems:
                 Expressiveness and Completeness}''",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "1",
  pages =        "208--208",
  month =        jan,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 12:58:29 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Widom:1992:TBN}.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Appel:1993:Ea,
  author =       "Andrew W. Appel",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "209--210",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:29:44 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Harper:1993:TSS,
  author =       "Robert Harper and John C. Mitchell",
  title =        "On the Type Structure of Standard {ML}",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "211--252",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/prog.lang.theory.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "Earlier version appears as ``The Essence of {ML}'' in
                 {\em Proc. 15th ACM Symp. on Principles of Programming
                 Languages}, 1988, pp. 28--46",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169696.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Abstract
                 data types. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Operational
                 semantics. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Lambda calculus and related systems. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, ML.",
}

@Article{Henglein:1993:TIP,
  author =       "Fritz Henglein",
  title =        "Type Inference with Polymorphic Recursion",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "253--289",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPPS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169692.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; ML; polymorphism;
                 semi-unification; theory; type inference",
  semno =        "D-127",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Lambda
                 calculus and related systems.",
  summary =      "It is shown that type inference for ML with
                 polymorphic recursion (Mycroft's extension) is
                 log-space equivalent to semi-unification. Since
                 semi-unification is undecidable so is type inference
                 with polymorphic recursion. Nonetheless reasons are
                 presented for its usability in practice.",
}

@Article{Kfoury:1993:TRP,
  author =       "A. J. Kfoury and J. Tiuryn and P. Urzyczyn",
  title =        "Type Recursion in the Presence of Polymorphic
                 Recursion",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "290--311",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169687.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs.
                 {\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory. {\bf D.3.2}: Software, PROGRAMMING LANGUAGES,
                 Language Classifications, Applicative languages. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic.",
}

@Article{Dhamdhere:1993:EAB,
  author =       "Dhananjay M. Dhamdhere and Harish Patil",
  title =        "An Elimination Algorithm for Bidirectional Data Flow
                 Problems Using Edge Placement",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "312--336",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169684.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 F.2.2}: Theory of Computation, ANALYSIS OF ALGORITHMS
                 AND PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems. {\bf F.3.3}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs.",
}

@Article{Katz:1993:SCC,
  author =       "Shmuel Katz",
  title =        "A Superimposition Control Construct for Distributed
                 Systems",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "337--356",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169682.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.1.3}: Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages.",
}

@Article{Copperman:1993:TCF,
  author =       "Max Copperman and Charles E. McDowell",
  title =        "Technical Correspondence: a Further Note on
                 {Hennessy}'s ``{Symbolic Debugging of Optimized
                 Code}''",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "2",
  pages =        "357--365",
  month =        apr,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:20:23 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Hennessy:1982:SDO}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/214526.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "performance; verification",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Symbolic execution. {\bf D.2.7}:
                 Software, SOFTWARE ENGINEERING, Distribution and
                 Maintenance. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding.",
}

@Article{Burke:1993:IOE,
  author =       "Michael Burke and Linda Torczon",
  title =        "Interprocedural Optimization: Eliminating Unnecessary
                 Recompilation",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "367--399",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/169678.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Chatterjee:1993:CND,
  author =       "Siddhartha Chatterjee",
  title =        "Compiling Nested Data-Parallel Programs for
                 Shared-Memory Multiprocessors",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "400--462",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174152.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Control structures. {\bf E.1}: Data, DATA
                 STRUCTURES. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf C.1.2}: Computer
                 Systems Organization, PROCESSOR ARCHITECTURES, Multiple
                 Data Stream Architectures (Multiprocessors).",
}

@Article{Consel:1993:PPE,
  author =       "Charles Consel and Siau Cheng Khoo",
  title =        "Parameterized Partial Evaluation",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "463--493",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/partial-eval.bib; Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 Theory/partial-eval.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174155.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors.",
}

@Article{Richardson:1993:DPL,
  author =       "Joel E. Richardson and Michael J. Carey and Daniel T.
                 Schuh",
  title =        "The Design of the {E} Programming Language",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "494--534",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174157.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, E. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Object-oriented
                 languages. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, C++. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features. {\bf H.2.3}: Information Systems,
                 DATABASE MANAGEMENT, Languages, Database (persistent)
                 programming languages.",
}

@Article{Odersky:1993:DCD,
  author =       "Martin Odersky",
  title =        "Defining Context-Dependent Syntax Without Using
                 Contexts",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "535--562",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174159.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Syntax. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Model theory. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Grammar types.
                 {\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing.",
}

@Article{Huang:1993:LEU,
  author =       "Shing-Tsaan Huang",
  title =        "Leader Election in Uniform Rings",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "3",
  pages =        "563--573",
  month =        jul,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174161.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; reliability; theory",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems. {\bf D.1.3}: Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management, Mutual
                 exclusion. {\bf D.4.5}: Software, OPERATING SYSTEMS,
                 Reliability, Fault-tolerance. {\bf F.1.2}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Modes of
                 Computation, Parallelism and concurrency.",
}

@Article{Amadio:1993:SRT,
  author =       "Roberto M. Amadio and Luca Cardelli",
  title =        "Subtyping Recursive Types",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "575--631",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155231.html",
  abstract =     "We investigate the interactions of subtyping and
                 recursive types, in a simply typed [lambda]-calculus.
                 The two fundamental questions here are whether two
                 (recursive)types are in the subtype relation and
                 whether a term has a type. To address the first
                 question, we relate various definitions of type
                 equivalence and subtyping that are induced by a model,
                 an ordering on infinite trees, an algorithm, and a set
                 of type rules. We show soundness and completeness among
                 the rules, the algorithm, and the tree semantics. We
                 also prove soundness and a restricted form of
                 completeness for the model. To address the second
                 question, we show that to every pair of types in the
                 subtype relation we can associate a term whose
                 denotation is the uniquely determined coercion map
                 between the two types. Moreover, we derive an algorithm
                 that, when given a term with implicit coercions, can
                 infer its least type whenever possible.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Program and recursion schemes. {\bf F.4.3}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Formal Languages, Classes defined by grammars or
                 automata. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Lambda calculus and related systems. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Recursion. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Abstract data types.",
}

@Article{Palem:1993:STC,
  author =       "Krishna V. Palem and Barbara B. Simons",
  title =        "Scheduling Time-Critical Instructions on {RISC}
                 Machines",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "632--658",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155190.html",
  abstract =     "We present a polynomial time algorithm for
                 constructing a minimum completion time schedule of
                 instructions from a basic block on RISC machines such
                 as the Sun SPARC, the IBM 801, the Berkeley RISC
                 machine, and the HP Precision Architecture. Our
                 algorithm can be used as a heuristic for RISC
                 processors with longer pipelines, for which there is no
                 known optimal algorithm. Our algorithm can also handle
                 time-critical instructions, which are instructions that
                 have to be completed by a specific time. Time-critical
                 instructions occur in some real-time computations, and
                 can also be used to make shared resources such as
                 registers quickly available for reuse. We also prove
                 that in the absence of time-critical constraints, a
                 greedy scheduling algorithm always produces a schedule
                 for a target machine with multiple identical pipelines
                 that has a length less than twice that of an optimal
                 schedule. The behavior of the heuristic is of interest
                 because, as we show, the instruction scheduling problem
                 becomes NP-hard for arbitrary length pipelines, even
                 when the basic block of code being input consists of
                 only several independent streams of straightline code,
                 and there are no time-critical constraints. Finally, we
                 prove that the problem becomes NP-hard even for small
                 pipelines, no time-critical constraints, and input of
                 several independent streams of straightline code if
                 either there is only a single register or if no two
                 instructions are allowed to complete simultaneously
                 because of some shared resource such as a bus.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance",
  subject =      "{\bf F.2.2}: Theory of Computation, ANALYSIS OF
                 ALGORITHMS AND PROBLEM COMPLEXITY, Nonnumerical
                 Algorithms and Problems, Sequencing and scheduling.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf C.1.1}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Single Data Stream Architectures, RISC.
                 {\bf F.1.3}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Complexity Classes, Reducibility and
                 completeness.",
}

@Article{Gupta:1993:APE,
  author =       "Gopal Gupta and Bharat Jayaraman",
  title =        "Analysis of {Or}-Parallel Execution Models",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "659--680",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155220.html",
  abstract =     "We discuss fundamental limitations of or-parallel
                 execution models of nondeterministic programming
                 languages. Or-parallelism corresponds to the execution
                 of different nondeterministic computational paths in
                 parallel. A natural way to represent the state of
                 (parallel) execution of a nondeterministic program is
                 by means of an or-parallel tree. We identify three
                 important criteria that underlie the design of
                 or-parallel implementations based on the or-parallel
                 tree: constant-time access to variables, constant-time
                 task creation, and constant-time task switching, where
                 the term {\em constant-time\/} means that the time for
                 these operations is independent of the number of nodes
                 in the or-parallel tree, as well as the size of each
                 node. We prove that all three criteria cannot be
                 simultaneously satisfied by any or-parallel execution
                 model based on a finite number of processors but
                 unbounded memory. We discuss in detail the application
                 of our result to the class of logic programming
                 languages and show how our result can serve as a useful
                 way to categorize the various or-parallel methods
                 proposed in this field. We also discuss the suitability
                 of different or-parallel implementation strategies for
                 different parallel architectures.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Run-time environments. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nondeterministic languages. {\bf
                 I.2.8}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Problem Solving, Control Methods, and
                 Search, Backtracking. {\bf C.1.2}: Computer Systems
                 Organization, PROCESSOR ARCHITECTURES, Multiple Data
                 Stream Architectures (Multiprocessors),
                 Multiple-instruction-stream, multiple-data-stream
                 processors (MIMD). {\bf D.1.6}: Software, PROGRAMMING
                 TECHNIQUES, Logic Programming.",
}

@Article{Fidge:1993:FDP,
  author =       "C. J. Fidge",
  title =        "A Formal Definition of Priority in {CSP}",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "681--705",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155221.html",
  abstract =     "The process models of Ada and occam are formally based
                 on the CSP process algebra. However, for fine-tuning
                 real-time performance, they include ``prioritized''
                 constructs that have no counterparts in CSP. These
                 constructs therefore lack any formal definition, a
                 situation that leaves room for misunderstandings. We
                 extend CSP with a formal definition of the notion of
                 priority. The definition is then used to assess the
                 transputer implementation of priority in occam and the
                 definition of priority in Ada.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, CSP. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, OCCAM. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Ada. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Concurrent programming structures. {\bf
                 F.3.2}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Operational semantics.",
}

@Article{Abadi:1993:CAC,
  author =       "Mart{\'\i}n Abadi and Michael Burrows and Butler
                 Lampson and Gordon Plotkin",
  title =        "A Calculus for Access Control in Distributed Systems",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "706--734",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155225.html",
  abstract =     "We study some of the concepts, protocols, and
                 algorithms for access control in distributed systems,
                 from a logical perspective. We account for how a
                 principal may come to believe that another principal is
                 making a request, either on his own or on someone
                 else's behalf. We also provide a logical language for
                 access control lists and theories for deciding whether
                 requests should be granted.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "security; theory; verification",
  subject =      "{\bf D.4.6}: Software, OPERATING SYSTEMS, Security and
                 Protection, Access controls. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic. {\bf D.4.6}: Software, OPERATING
                 SYSTEMS, Security and Protection, Authentication. {\bf
                 D.4.6}: Software, OPERATING SYSTEMS, Security and
                 Protection, Verification. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems.",
}

@Article{Ghosh:1993:ASP,
  author =       "Sukumar Ghosh",
  title =        "An Alternative Solution to a Problem on
                 Self-Stabilization",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "4",
  pages =        "735--742",
  month =        sep,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/155228.html",
  abstract =     "Dijkstra [4, 5] introduced the problem of
                 self-stabilization in distributed systems as an
                 interesting exercise for achieving global convergence
                 through local actions. In [4] he presented three
                 solutions to a specific version of the
                 self-stabilization problem, one of which was proved in
                 [6]. This paper presents an alternative solution of his
                 self-stabilization problem with four-state machines.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Distributed applications. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management,
                 Synchronization.",
}

@Article{Appel:1993:Eb,
  author =       "A. W. Appel and S. L. Graham",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "743--744",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Herlihy:1993:MIH,
  author =       "Maurice Herlihy",
  title =        "A Methodology for Implementing Highly Concurrent Data
                 Objects",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "745--770",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/161469.html",
  abstract =     "A {\em concurrent object\/} is a data structure shared
                 by concurrent processes. Conventional techniques for
                 implementing concurrent objects typically rely on {\em
                 critical sections\/}; ensuring that only one process at
                 a time can operate on the object. Nevertheless,
                 critical sections are poorly suited for asynchronous
                 systems: if one process is halted or delayed in a
                 critical section, other, nonfaulty processes will be
                 unable to progress. By contrast, a concurrent object
                 implementation is {\em lock free\/} if it always
                 guarantees that some process will complete an operation
                 in a finite number of steps, and it is {\em wait
                 free\/} if it guarantees that {\em each\/} process will
                 complete an operation in a finite number of steps. This
                 paper proposes a new methodology for constructing
                 lock-free and wait-free implementations of concurrent
                 objects. The object's representation and operations are
                 written as stylized sequential programs, with no
                 explicit synchronization. Each sequential operation is
                 automatically transformed into a lock-free or wait-free
                 operation using novel synchronization and memory
                 management algorithms. These algorithms are presented
                 for a multiple instruction/multiple data (MIMD)
                 architecture in which $n$ processes communicate by
                 applying atomic {\em read, write, load\_linked,\/} and
                 {\em store\_conditional\/} operations to a shared
                 memory.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.1.3}: Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming. {\bf D.4.2}:
                 Software, OPERATING SYSTEMS, Storage Management.",
}

@Article{Leivent:1993:MFT,
  author =       "Jonathan I. Leivent and Ronald J. Watro",
  title =        "Mathematical Foundations for {Time Warp} Systems",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "771--794",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:24:08 1997",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/161470.html",
  abstract =     "We develop a simple formal model of the Time Warp
                 approach to distributed computation, prove several
                 important properties of the model, and devise some
                 extensions to Time Warp that provide improved
                 termination behavior. Our model consists of processes
                 that communicate solely via message passing. One of the
                 basic process steps is a rollback operation that
                 includes message retraction via transmission of
                 antimessages. In the model, we consider three problems:
                 safety, progress, and termination. By safety, we mean
                 that for a given system of processes, if a run of the
                 system terminates, then the final system state of the
                 run is identical to the final system state of a
                 rollback-free run. We give premises that imply safety,
                 and a counterexample that shows how safety can fail. By
                 progress, we mean that, as a run of a system proceeds,
                 the minimum timestamp of an unprocessed message always
                 eventually increases. We state three axioms that imply
                 the progress property. By termination, we mean that, if
                 all rollback-free runs of a system terminate, then all
                 runs terminate. The termination property is generally
                 false in existing implementations of Time Warp systems
                 due to the possibility of Time Warp vortices. We define
                 additional mechanisms that can guarantee the
                 termination property for most Time Warp applications.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf I.6.1}: Computing Methodologies, SIMULATION AND
                 MODELING, Simulation Theory. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Synchronization. {\bf F.1.2}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Modes of
                 Computation, Parallelism and concurrency.",
}

@Article{Bowman:1993:RAN,
  author =       "Mic Bowman and Saumya K. Debray and Larry L.
                 Peterson",
  title =        "Reasoning About Naming Systems",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "795--825",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/161471.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; theory",
  subject =      "{\bf H.3.4}: Information Systems, INFORMATION STORAGE
                 AND RETRIEVAL, Systems and Software, Question-answering
                 (fact retrieval) systems. {\bf H.2.3}: Information
                 Systems, DATABASE MANAGEMENT, Languages, Query
                 languages. {\bf H.2.4}: Information Systems, DATABASE
                 MANAGEMENT, Systems, Query processing. {\bf H.3.3}:
                 Information Systems, INFORMATION STORAGE AND RETRIEVAL,
                 Information Search and Retrieval, Selection process.",
}

@Article{Debray:1993:CAL,
  author =       "Saumya K. Debray and Nai-Wei Lin",
  title =        "Cost Analysis of Logic Programs",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "826--875",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/161472.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.2.8}: Software, SOFTWARE ENGINEERING, Metrics,
                 Performance measures. {\bf D.1.6}: Software,
                 PROGRAMMING TECHNIQUES, Logic Programming. {\bf D.2.8}:
                 Software, SOFTWARE ENGINEERING, Metrics, Complexity
                 measures. {\bf D.3.2}: Software, PROGRAMMING LANGUAGES,
                 Language Classifications, Nonprocedural languages. {\bf
                 I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Automatic analysis
                 of algorithms.",
}

@Article{Lin:1993:PIA,
  author =       "Huimin Lin",
  title =        "Procedural Implementation of Algebraic Specification",
  journal =      j-TOPLAS,
  volume =       "15",
  number =       "5",
  pages =        "876--895",
  month =        nov,
  year =         "1993",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/161473.html",
  abstract =     "An implementation of an algebraic specification in an
                 imperative programming language consists of a
                 representation type, together with an invariant and an
                 equivalence relation over it, and a procedure for each
                 operator in the specification. A formal technique is
                 developed to check the correctness of an implementation
                 with respect to its specification. Here ``correctness''
                 means that the implementation satisfies the axioms and
                 preserves the behavior of the specification. Within
                 legal representing value space, a correct
                 implementation behaves like a desirable model of the
                 specification. A notion of implementation refinement is
                 also proposed, and it is shown that the correctness
                 relation between implementations and specifications is
                 preserved by implementation refinement. In the extreme
                 case the procedures in an implementation may be
                 pre-post-condition pairs. Such abstract implementations
                 can be refined into executable code by refining the
                 abstract procedures in it. In this way a formal link
                 between the algebraic and the pre-post-condition
                 specification techniques is established.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; theory; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques,
                 Top-down programming. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Abstract
                 data types. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages. {\bf D.3.3}: Software, PROGRAMMING LANGUAGES,
                 Language Constructs and Features, Procedures,
                 functions, and subroutines. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf D.2.1}: Software,
                 SOFTWARE ENGINEERING, Requirements/Specifications,
                 Spec.",
}

@Article{Appel:1994:PS,
  author =       "Andrew Appel",
  title =        "Purpose and Scope",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "1",
  pages =        "1--2",
  month =        jan,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tick:1994:DTN,
  author =       "E. Tick and M. Korsloot",
  title =        "Determinacy Testing for Nondeterminate Logic
                 Programming Languages",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "1",
  pages =        "3--34",
  month =        jan,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174626.html",
  abstract =     "This paper describes an algorithm for the code
                 generation of determinacy testing for nondeterminate
                 flat concurrent logic programming languages. Languages
                 such as Andorra and Pandora require that procedure
                 invocations suspend if there is more than one candidate
                 clause potentially satisfying the goal. The algorithm
                 described has been developed specifically for a variant
                 of flat Pandora based on FGHC, although the concepts
                 are general. We have extended Kliger and Shapiro's
                 decision-graph construction algorithm to compile
                 ``don't-know'' procedures that must suspend for
                 nondeterminate goal invocation. The determinacy test is
                 compiled into a decision graph quite different from
                 those of committed-choice procedures: They are more
                 similar to decision trees optimized by code sharing. We
                 present both empirical data of compilation results
                 (code size and graph characteristics), and a
                 correctness proof for our code-generation algorithm.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf D.1.6}: Software,
                 PROGRAMMING TECHNIQUES, Logic Programming. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{LeCharlier:1994:EEG,
  author =       "Baudouin {Le Charlier} and Pascal {Van Hentenryck}",
  title =        "Experimental Evaluation of a Generic Abstract
                 Interpretation Algorithm for {PROLOG}",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "1",
  pages =        "35--101",
  month =        jan,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:59:10 1998",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174627.html",
  abstract =     "Abstract interpretation of PROLOG programs has
                 attracted many researchers in recent years, partly
                 because of the potential for optimization in PROLOG
                 compilers and partly because of the declarative nature
                 of logic programming languages that make them more
                 amenable to optimization than procedural languages.
                 Most of the work, however, has remained at the
                 theoretical level, focusing on the developments of
                 frameworks and the definition of abstract
                 domains.\par

                 This paper reports our effort to verify experimentally
                 the practical value of this area of research. It
                 describes the design and implementation of the generic
                 abstract interpretation algorithm GAIA that we
                 originally proposed in Le Charlier et al. [1991], its
                 instantiation to a sophisticated abstract domain
                 (derived from Bruynooghe and Janssens [1988])
                 containing modes, types, sharing, and aliasing, and its
                 evaluation both in terms of performance and accuracy.
                 The overall implementation (over 5000 lines of Pascal)
                 has been systematically analyzed on a variety of
                 programs and compared with the complexity analysis of
                 Le Charlie et al. [1991] and the specific analysis
                 systems of Hickey and Mudambi [1989], Taylor [1989;
                 1990], Van Roy and Despain [1990], and Warren et al.
                 [1988].",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Prolog.",
}

@Article{Waters:1994:CBP,
  author =       "Richard C. Waters",
  title =        "Clich{\'e}-Based Program Editors",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "1",
  pages =        "102--150",
  month =        jan,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174628.html",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; experimentation",
  subject =      "{\bf D.2.3}: Software, SOFTWARE ENGINEERING, Coding,
                 Program editors. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Programmer
                 workbench. {\bf D.2.2}: Software, SOFTWARE ENGINEERING,
                 Tools and Techniques, Software libraries. {\bf D.2.3}:
                 Software, SOFTWARE ENGINEERING, Coding, Pretty
                 printers. {\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf I.2.2}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Program synthesis. {\bf K.6.3}: Computing
                 Milieux, MANAGEMENT OF COMPUTING AND INFORMATION
                 SYSTEMS, Software Management, Software development.
                 {\bf K.6.3}: Computing Milieux, MANAGEMENT OF COMPUTING
                 AND INFORMATION SYSTEMS, Software Management, Software
                 maintenance. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Computer-aided
                 software engineering (CASE).",
}

@Article{Purtilo:1994:PSB,
  author =       "James M. Purtilo",
  title =        "The {POLYLITH} Software Bus",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "1",
  pages =        "151--174",
  month =        jan,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174629.html",
  abstract =     "We describe a system called POLYLITH that helps
                 programmers prepare and interconnect mixed-language
                 software components for execution in heterogeneous
                 environments. POLYLITH's principal benefit is that
                 programmers are free to implement functional
                 requirements separately from their treatment of
                 interfacing requirements; this means that once an
                 application has been developed for use in one execution
                 environment (such as a distributed network) it can be
                 adapted for reuse in other environments (such as a
                 shared-memory multiprocessor) by automatic techniques.
                 This flexibility is provided without loss of
                 performance. We accomplish this by creating a new
                 run-time organization for software. An abstract
                 decoupling agent, called the {\em software bus}, is
                 introduced between the system components. Heterogeneity
                 in language and architecture is accommodated since
                 program units are prepared to interface directly to the
                 bus and not to other program units. Programmers specify
                 application structure in terms of a module
                 interconnection language (MIL); POLYLITH uses this
                 specification to guide {\em packaging\/} (static
                 interfacing activities such as stub generation, source
                 program adaptation, compilation, and linking). At run
                 time, an implementation of the bus abstraction may
                 assist in message delivery, name service, or system
                 reconfiguration.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors.",
}

@Article{Harrold:1994:ECI,
  author =       "Mary Jean Harrold and Mary Lou Soffa",
  title =        "Efficient Computation of Interprocedural
                 Definition-Use Chains",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "2",
  pages =        "175--204",
  month =        mar,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174663.html",
  abstract =     "The dependencies that exist among definitions and uses
                 of variables in a program are required by many
                 language-processing tools. This paper considers the
                 computation of definition-use and use-definition chains
                 that extend across procedure boundaries at call and
                 return sites. Intraprocedural definition and use
                 information is abstracted for each procedure and is
                 used to construct an interprocedural flow graph. This
                 intraprocedural data-flow information is then
                 propagated throughout the program via the
                 interprocedural flow graph to obtain sets of reaching
                 definitions and/or reachable uses for reach
                 interprocedural control point, including procedure
                 entry, exit, call, and return. Interprocedural
                 definition-use and/or use-definition chains are
                 computed from this reaching information. The technique
                 handles the interprocedural effects of the data flow
                 caused by both reference parameters and global
                 variables, while preserving the calling context of
                 called procedures. Additionally, recursion, aliasing,
                 and separate compilation are handled. The technique has
                 been implemented using a Sun-4 Workstation and
                 incorporated into an interprocedural data-flow tester.
                 Results from experiments indicate the practicality of
                 the technique, both in terms of the size of the
                 interprocedural flow graph and the size of the
                 data-flow sets.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.2.5}: Software,
                 SOFTWARE ENGINEERING, Testing and Debugging. {\bf
                 D.2.6}: Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers.",
}

@Article{Mulkers:1994:LSD,
  author =       "Anne Mulkers and William Winsborough and Maurice
                 Bruynooghe",
  title =        "Live-Structure Dataflow Analysis for {Prolog}",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "2",
  pages =        "205--258",
  month =        mar,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174664.html",
  abstract =     "For the class of applicative programming languages,
                 efficient methods for reclaiming the memory occupied by
                 released data structures constitute an important aspect
                 of current implementations. The present article
                 addresses the problem of memory reuse for logic
                 programs through program analysis rather than by
                 run-time garbage collection. The aim is to derive
                 run-time properties that can be used at compile time to
                 specialize the target code for a program according to a
                 given set of queries and to automatically introduce
                 destructive assignments in a safe and transparent way
                 so that fewer garbage cells are created.\par

                 The dataflow analysis is constructed as an application
                 of abstract interpretation for logic programs. An
                 abstract domain for describing structure-sharing and
                 liveness properties is developed as are primitive
                 operations that guarantee a sound and terminating
                 global analysis. We explain our motivation for the
                 design of the abstract domain, make explicit the
                 underlying implementation assumptions, and discuss the
                 precision of the results obtained by a prototype
                 analyzer.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Prolog. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf I.2.3}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving, Logic programming.",
}

@Article{Jonsson:1994:CSV,
  author =       "Bengt Jonsson",
  title =        "Compositional Specification and Verification of
                 Distributed Systems",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "2",
  pages =        "259--303",
  month =        mar,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/174665.html",
  abstract =     "We present a method for specification and verification
                 of distributed systems that communicate via
                 asynchronous message passing. The method handles both
                 safety and liveness properties. It is compositional,
                 i.e., a specification of a composite system can be
                 obtained from specifications of its components.
                 Specifications are given as labeled transition systems
                 with fairness properties, using a program-like notation
                 with guarded multiple assignments. Compositionality is
                 attained by partitioning the labels of a transition
                 system into input events, which intuitively denote
                 message receptions, and output events, which
                 intuitively denote message transmissions. A
                 specification denotes a set of allowed sequences of
                 message transmissions and receptions, in analogy with
                 the way finite automata are used as acceptors of finite
                 strings. A lower-level specification implements a
                 higher-level one. We present a verification technique
                 which reduces the problem of verifying the correctness
                 of an implementation to classical verification
                 conditions. Safety properties are verified by
                 establishing a simulation relation between transition
                 systems. Liveness properties are verified using methods
                 for proving termination under fairness assumptions.
                 Since specifications can be given at various levels of
                 abstraction, the method is suitable in a development
                 process where a detailed implementation is developed
                 from an abstract specification through a sequence of
                 refinement steps. As an application of the method, an
                 algorithm by Thomas for updating a distributed database
                 is specified and verified.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf C.2.2}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Network Protocols,
                 Protocol verification. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications,
                 Methodologies. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness
                 proofs.",
}

@Article{Pinter:1994:POP,
  author =       "Shlomit S. Pinter and Ron Y. Pinter",
  title =        "Program Optimization and Parallelization Using
                 Idioms",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "305--327",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177494.html",
  abstract =     "Programs in languages such as Fortran, Pascal, and C
                 were designed and written for a sequential machine
                 model. During the last decade, several methods to
                 vectorize such programs and recover other forms of
                 parallelism that apply to more advanced machine
                 architectures have been developed (particularly for
                 Fortran, due to its pointer-free semantics). We propose
                 and demonstrate a more powerful translation technique
                 for making such programs run efficiently on parallel
                 machines which support facilities such as parallel
                 prefix operations as well as parallel and vector
                 capabilities. This technique, which is global in nature
                 and involves a modification of the traditional
                 definition of the program dependence graph (PDG), is
                 based on the extraction of parallelizable program
                 structures (``idioms'') from the given (sequential)
                 program. The benefits of our technique extend beyond
                 the above-mentioned architectures and can be viewed as
                 a general program optimization method, applicable in
                 many other situations. We show a few examples in which
                 our method indeed outperforms existing analysis
                 techniques.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Optimization.",
}

@Article{Bloss:1994:PAO,
  author =       "Adrienne Bloss",
  title =        "Path Analysis and the Optimization of Nonstrict
                 Functional Languages",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "328--369",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177497.html",
  abstract =     "The functional programming style is increasingly
                 popular in the research world, but functional languages
                 still execute slowly relative to imperative languages.
                 This is largely because the power and flexibility of
                 functional languages restrict the amount of information
                 readily available to the compiler, hindering its
                 ability to generate good code. This article
                 demonstrates that information about {\em order of
                 evaluation of expressions\/} can be statically inferred
                 for nonstrict functional programs and that
                 optimizations based on this information can provide
                 substantial speedups at runtime. We present an exact,
                 nonstandard semantics called {\em path semantics\/}
                 that models order of evaluation in a nonstrict,
                 sequential functional language, and its computable
                 abstraction, {\em path analysis}. We show how the
                 information inferred by path analysis can be used to
                 implement destructive aggregate updating, in which
                 updates on functional aggregates that are provably not
                 live are done destructively. We also demonstrate a new
                 approach to strictness analysis and show that
                 strictness analysis is subsumed by path analysis.
                 Benchmarks are presented.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; performance",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf E.1}: Data, DATA STRUCTURES, Arrays.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics.",
}

@Article{Gupta:1994:ERA,
  author =       "Rajiv Gupta and Mary Lou Soffa and Denise Ombres",
  title =        "Efficient Register Allocation via Coloring Using
                 Clique Separators",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "370--386",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177499.html",
  abstract =     "Although graph coloring is widely recognized as an
                 effective technique for register allocation, memory
                 demands can become quite high for large interference
                 graphs that are needed in coloring. In this paper we
                 present an algorithm that uses the notion of clique
                 separators to improve the space overhead of coloring.
                 The algorithm, based on a result by R. Tarjan regarding
                 the colorability of graphs, partitions program code
                 into code segments using clique separators. The
                 interference graphs for the code partitions are
                 constructed one at a time and colored independently.
                 The colorings for the partitions are combined to obtain
                 a register allocation for the entire program. This
                 approach can be used to perform register allocation in
                 a space-efficient manner. For straight-line code (e.g.,
                 local register allocation), an optimal allocation can
                 be obtained from optimal allocations for individual
                 code partitions. Experimental results are presented
                 demonstrating memory demand reductions for interference
                 graphs when allocating registers using clique
                 separators.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf C.0}: Computer Systems
                 Organization, GENERAL, Hardware/software interfaces.",
}

@Article{Copperman:1994:DOC,
  author =       "Max Copperman",
  title =        "Debugging Optimized Code Without Being Misled",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "387--427",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177517.html",
  abstract =     "Correct optimization can change the behavior of an
                 incorrect program; therefore at times it is necessary
                 to debug optimized code. However, optimizing compilers
                 produce code that impedes source-level
                 debugging.\par

                 Optimization can cause an inconsistency between where
                 the user expects a breakpoint to be located and the
                 breakpoint's actual location. This article describes a
                 mapping between statements and breakpoint locations
                 that ameliorates this problem. The mapping enables
                 debugger behavior on optimized code that approximates
                 debugger behavior on unoptimized code sufficiently
                 closely for the user to use traditional debugging
                 strategies.\par

                 Optimization can also cause the value of a variable to
                 be {\em noncurrent\/}---to differ from the value that
                 would be predicted by a close reading of the source
                 code. This article presents a method of determining
                 when this has occurred, and shows how a debugger can
                 describe the relevant effects of optimization. The
                 determination method is more general than previously
                 published methods; it handles global optimization and
                 many flow graph transformations, and it is not tightly
                 coupled to optimizations performed by a particular
                 compiler. Necessary compiler support is also
                 described.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "performance; verification",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Code generation. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Briggs:1994:IGC,
  author =       "Preston Briggs and Keith D. Cooper and Linda Torczon",
  title =        "Improvements to Graph Coloring Register Allocation",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "428--455",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177575.html",
  abstract =     "We describe two improvements to Chaitin-style graph
                 coloring register allocators. The first, {\em
                 optimistic coloring}, uses a stronger heuristic to find
                 a $k$-coloring for the interference graph. The second
                 extends Chaitin's treatment of {\em
                 rematerialization\/} to handle a larger class of
                 values. These techniques are complementary. Optimistic
                 coloring decreases the number of procedures that
                 require spill code and reduces the amount of spill code
                 when spilling is unavoidable. Rematerialization lowers
                 the cost of spilling some values. This paper describes
                 both of the techniques and our experience building and
                 using register allocators that incorporate them. It
                 provides a detailed description of optimistic coloring
                 and rematerialization. It presents experimental data to
                 show the performance of several versions of the
                 register allocator on a suite of FORTRAN programs. It
                 discusses several insights that we discovered only
                 after repeated implementation of these allocators.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Jagannathan:1994:MBB,
  author =       "Suresh Jagannathan",
  title =        "Metalevel Building Blocks for Modular Systems",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "456--492",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177578.html",
  abstract =     "The formal definition of any namespace device found in
                 a programming language can be given in terms of
                 transformations on a semantic environment. It is
                 worthwhile, therefore, to consider the implications of
                 incorporating environments as bona fide data objects in
                 a programming system.\par

                 In this article, we propose a treatment of environments
                 and the mechanism by which they are reified and
                 manipulated, that addresses these concerns. The
                 language described below (Rascal) permits environments
                 to be reified into data structures, and data structures
                 to be reflected into environments, but gives users
                 great flexibility to constrain the extent and scope of
                 these processes. We argue that the techniques and
                 operators developed define a cohesive basis for
                 building large-scale modular systems using reflective
                 programming techniques.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.2}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Denotational semantics.",
}

@Article{Kennaway:1994:AGR,
  author =       "J. R. Kennaway and J. W. Klop and M. R. Sleep and F.
                 J. {De Vries}",
  title =        "On the Adequacy of Graph Rewriting for Simulating Term
                 Rewriting",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "493--523",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177577.html",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems. {\bf F.1.1}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Models of Computation.
                 {\bf F.4.1}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic.",
}

@Article{Crowl:1994:PPC,
  author =       "Lawrence A. Crowl and Thomas J. LeBlanc",
  title =        "Parallel Programming with Control Abstraction",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "524--576",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177584.html",
  abstract =     "Parallel programming involves finding the potential
                 parallelism in an application and mapping it to the
                 architecture at hand. Since a typical application has
                 more potential parallelism than any single architecture
                 can exploit effectively, programmers usually limit
                 their focus to the parallelism that the available
                 control constructs express easily and that the given
                 architecture exploits efficiently. This approach
                 produces programs that exhibit much less parallelism
                 that exists in the application, and whose performance
                 depends critically on the underlying hardware and
                 software.\par

                 We argue for an alternative approach based on {\em
                 control abstraction}. Control abstraction is the
                 process by which programmers define new control
                 constructs, specifying constraints on statement
                 ordering separately from an implementation of that
                 ordering. With control abstraction programmers can
                 define and use a rich variety of control constructs to
                 represent an algorithm's potential
                 parallelism.\par

                 Since control abstraction separates the definition of a
                 construct from its implementation, a construct may have
                 several different implementations, each exploiting a
                 different subset of the parallelism admitted by the
                 construct. By selecting an implementation for each
                 control construct using annotations, a programmer can
                 vary the parallelism in a program to best exploit the
                 underlying hardware without otherwise changing the
                 source code. This approach produces programs that
                 exhibit most of the potential parallelism in an
                 algorithm, and whose performance can be tuned simply by
                 choosing among the various implementations for the
                 control constructs in use.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.1.3}: Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming, Parallel
                 programming. {\bf D.2.m}: Software, SOFTWARE
                 ENGINEERING, Miscellaneous, Reusable software. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Abstract
                 data types. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Control
                 structures. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features,
                 Procedures, functions, and subroutines. {\bf F.3.3}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs, Control primitives.",
}

@Article{Foster:1994:CAS,
  author =       "Ian Foster and Stephen Taylor",
  title =        "A Compiler Approach to Scalable Concurrent-Program
                 Design",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "577--604",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177612.html",
  abstract =     "We describe a compilation system for the concurrent
                 programming language Program Composition Notation
                 (PCN). This notation provides a {\em single-assignment
                 programming model\/} that permits
                 concurrent-programming concerns such as decomposition,
                 communication, synchronization, mapping, granularity,
                 and load balancing to be addressed separately in a
                 design. PCN is also extensible with {\em
                 programmer-defined operators}, allowing common
                 abstractions to be encapsulated and reused in different
                 contexts.\par

                 The compilation system incorporates a {\em
                 concurrent-transformation system\/} that allows
                 abstractions to be defined through concurrent
                 source-to-source transformations; these convert
                 programmer-defined operators into a core notation. {\em
                 Run-time techniques\/} allow the core notation to be
                 compiled into a simple concurrent abstract machine
                 which can be implemented in a portable fashion using a
                 run-time library. The abstract machine provides a
                 uniform treatment of single-assignment and mutable data
                 structures, allowing data sharing between concurrent
                 and sequential program segments and permitting
                 integration of sequential C and Fortran code into
                 concurrent programs.\par

                 This compilation system forms part of a program
                 development toolkit that operates on a wide variety of
                 networked workstations, multicomputers, and
                 shared-memory multiprocessors. The toolkit has been
                 used both to develop substantial applications and to
                 teach introductory concurrent-programming classes,
                 including a freshman course at Caltech.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.2.10}: Software, SOFTWARE ENGINEERING, Design,
                 Methodologies. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Run-time environments.",
}

@Article{Arbab:1994:SCD,
  author =       "Bijan Arbab and Daniel Berry",
  title =        "Some Comments on ``{A} Denotational Semantics for
                 {Prolog}''",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "605--606",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177605.html",
  abstract =     "Two independently derived denotational semantics for
                 Prolog are contrasted, Arbab and Berry's for the full
                 language and Nicholson and Foo's for a databaseless
                 language. Using the ideas suggested by the former, the
                 latter can be easily extended to include the database
                 operations.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Logic programming.",
}

@Article{Marriott:1994:DAI,
  author =       "Kim Marriott and Harald S{\o}ndergaard and Neil D.
                 Jones",
  title =        "Denotational Abstract Interpretation of Logic
                 Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "607--648",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib; Compiler/TOPPS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177650.html",
  abstract =     "Logic-programming languages are based on a principle
                 of separation ``logic'' and ``control.''. This means
                 that they can be given simple model-theoretic semantics
                 without regard to any particular execution mechanism
                 (or proof procedure, viewing execution as theorem
                 proving). Although the separation is desirable from a
                 semantical point of view, it makes sound, efficient
                 implementation of logic-programming languages
                 difficult. The lack of ``control information'' in
                 programs calls for complex data-flow analysis
                 techniques to guide execution. Since data-flow analysis
                 furthermore finds extensive use in error-finding and
                 transformation tools, there is a need for a simple and
                 powerful theory of data-flow analysis of logic
                 programs.\par

                 This paper offers such a theory, based on F. Nielson's
                 extension of P. Cousot and R. Cousot's {\em abstract
                 interpretation}. We present a denotational definition
                 of the semantics of definite logic programs. This
                 definition is of interest in its own right because of
                 its compactness. Stepwise we develop the definition
                 into a generic data-flow analysis that encompasses a
                 large class of data-flow analyses based on the SLD
                 execution model. We exemplify one instance of the
                 definition by developing a provably correct groundness
                 analysis to predict how variables may be bound to
                 ground terms during execution. We also discuss
                 implementation issues and related work.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; flow analysis; languages;
                 logical relations; Prolog; theory",
  semno =        "D-94",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.3.3}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic, Logic programming.",
  summary =      "A framework is established for the static analysis of
                 prolog programs. The framework is quite general and is
                 solidly based in a formal semantics, thus enabling
                 rigorous correctness proofs of various analyses. The
                 methods used include an adaptation of logical relations
                 as applied by Nielson and Nielson.",
}

@Article{Codish:1994:SAC,
  author =       "Michael Codish and Moreno Falaschi and Kim Marriott",
  title =        "Suspension Analyses for Concurrent Logic Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "649--686",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177656.html",
  abstract =     "Concurrent logic languages specify reactive systems
                 which consist of collections of communicating
                 processes. The presence of unintended suspended
                 computations is a common programming error which is
                 difficult to detect using standard debugging and
                 testing techniques. We develop a number of analyses,
                 based on abstract interpretation, which succeed if a
                 program is definitely suspension free. If an analysis
                 fails, the program may, or may not, be suspension free.
                 Examples demonstrate that the analyses are practically
                 useful. They are conceptually simple and easy to
                 justify because they are based directly on the
                 transition system semantics of concurrent logic
                 programs. A naive analysis must consider {\em all
                 scheduling policies}. However, it is proven that for
                 our analyses it suffices to consider only {\em one\/}
                 scheduling policy, allowing for efficient
                 implementation.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Assertions. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Invariants. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Concurrent,
                 distributed, and parallel languages. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Operational semantics.",
}

@Article{Apt:1994:OCF,
  author =       "Krzysztof R. Apt and Alessando Pellegrini",
  title =        "On the Occur-Check-Free {Prolog} Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "687--726",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177673.html",
  abstract =     "In most PROLOG implementations, for efficiency
                 occur-check is omitted from the unification algorithm.
                 This paper provides natural syntactic conditions that
                 allow the occur-check to be safely omitted. The
                 established results apply to most well-known PROLOG
                 programs, including those that use difference lists,
                 and seem to explain why this omission does not lead in
                 practice to any complications. When applying these
                 results to general programs, we show their usefulness
                 for proving absence of floundering. Finally, we propose
                 a program transformation that transforms every program
                 into a program for which only the calls to the built-in
                 unification predicate need to be resolved by a
                 unification algorithm with the occur-check.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Prolog. {\bf F.4.1}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Mathematical Logic, Logic programming. {\bf F.4.1}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Mechanical theorem
                 proving. {\bf D.2.4}: Software, SOFTWARE ENGINEERING,
                 Program Verification, Correctness proofs. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Preprocessors.",
}

@Article{Garlan:1994:TAM,
  author =       "David Garlan and Charles W. Krueger and Barbara S.
                 Lerner",
  title =        "{TransformGen}: Automating the Maintenance of
                 Structure-Oriented Environments",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "727--774",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177697.html",
  abstract =     "A serious problem for programs that use persistent
                 data is that information created and maintained by the
                 program becomes invalid if the persistent types used in
                 the program are modified in a new release.
                 Unfortunately, there has been little systematic
                 treatment of the problem; current approaches are
                 manual, ad hoc, and time consuming both for programmers
                 and users. In this article we present a new approach.
                 Focusing on the special case of managing abstract
                 syntax trees in structure-oriented environments, we
                 show how automatic transformers can be generated in
                 terms of an implementor's changes to the grammar of
                 these environments.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments. {\bf D.2.2}: Software,
                 SOFTWARE ENGINEERING, Tools and Techniques. {\bf
                 D.2.6}: Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.2.7}: Software, SOFTWARE
                 ENGINEERING, Distribution and Maintenance. {\bf H.2.1}:
                 Information Systems, DATABASE MANAGEMENT, Logical
                 Design, Schema and subschema.",
}

@Article{Yu:1994:LTS,
  author =       "Lin Yu and Daniel J. Rosenkrantz",
  title =        "A Linear-Time Scheme for Version Reconstruction",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "775--797",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177705.html",
  abstract =     "An efficient scheme to store and reconstruct versions
                 of sequential files is presented. The reconstruction
                 scheme involves building a data structure representing
                 a complete version, and then successively modifying
                 this data structure by applying a sequence of specially
                 formatted differential files to it. Each application of
                 a differential file produces a representation of an
                 intermediate version, with the final data structure
                 representing the requested version.\par

                 The scheme uses a linked list to represent an
                 intermediate version, instead of a sequential array, as
                 is used traditionally. A new format for differential
                 files specifying changes to this linked list data
                 structure is presented. The specification of each
                 change points directly to where the change is to take
                 place, thereby obviating a search. Algorithms are
                 presented for using such a new format differential file
                 to transform the representation of a version, and for
                 reconstructing a requested version. Algorithms are also
                 presented for generating the new format differential
                 files, both for the case of a forward differential
                 specifying how to transform the representation of an
                 old version to the representation of a new version, and
                 for the case of a reverse differential specifying how
                 to transform the representation of a new version to the
                 representation of an old version.\par

                 The new version reconstruction scheme takes time linear
                 in the sum of the size of the initial complete version
                 and the sizes of the file differences involved in
                 reconstructing the requested version. In contrast, the
                 classical scheme for reconstructing versions takes time
                 proportional to the sum of the sizes of the sequence of
                 versions involved in the reconstruction, and therefore
                 has a worst-case time that is quadratic in the sum of
                 the size of the initial complete version and the sizes
                 of the file differences. The time cost of the new
                 differential file generation scheme is comparable to
                 the time cost of the classical differential file
                 generation scheme.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf H.2.5}: Information Systems, DATABASE MANAGEMENT,
                 Heterogeneous Databases, Program translation. {\bf
                 H.3.2}: Information Systems, INFORMATION STORAGE AND
                 RETRIEVAL, Information Storage, File organization. {\bf
                 H.2.1}: Information Systems, DATABASE MANAGEMENT,
                 Logical Design. {\bf H.2.0}: Information Systems,
                 DATABASE MANAGEMENT, General, Security, integrity, and
                 protection. {\bf H.2.5}: Information Systems, DATABASE
                 MANAGEMENT, Heterogeneous Databases, Data translation.
                 {\bf D.2.7}: Software, SOFTWARE ENGINEERING,
                 Distribution and Maintenance.",
}

@Article{Rao:1994:RAP,
  author =       "Josyula R. Rao",
  title =        "Reasoning about Probabilistic Parallel Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "798--842",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177724.html",
  abstract =     "The use of randomization in the design and analysis of
                 algorithms promises simple and efficient algorithms to
                 difficult problems, some of which may not have a
                 deterministic solution. This gain in simplicity,
                 efficiency, and solvability results in a trade-off of
                 the traditional notion of absolute correctness of
                 algorithms for a more quantitative notion: correctness
                 with a probability between 0 and 1. The addition of the
                 notion of parallelism to the already unintuitive idea
                 of randomization makes reasoning about probabilistic
                 parallel programs all the more tortuous and
                 difficult.\par

                 In this paper we address the problem of specifying and
                 deriving properties of probabilistic parallel programs
                 that either hold deterministically or with probability
                 1. We present a proof methodology based on existing
                 proof systems for probabilistic algorithms, the theory
                 of the predicate transformer, and the theory of UNITY.
                 Although the proofs of probabilistic programs are
                 slippery at best, we show that such programs can be
                 derived with the same rigor and elegance that we have
                 seen in the derivation of sequential and parallel
                 programs. By applying this methodology to derive
                 probabilistic programs, we hope to develop tools and
                 techniques that would make randomization a useful
                 paradigm in algorithm design.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming,
                 Parallel programming. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Correctness proofs.
                 {\bf D.2.10}: Software, SOFTWARE ENGINEERING, Design,
                 Methodologies. {\bf G.3}: Mathematics of Computing,
                 PROBABILITY AND STATISTICS, Probabilistic algorithms
                 (including Monte Carlo).",
}

@Article{Grumberg:1994:MCM,
  author =       "Orna Grumberg and David E. Long",
  title =        "Model Checking and Modular Verification",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "843--871",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177725.html",
  abstract =     "We describe a framework for compositional verification
                 of finite-state processes. The framework is based on
                 two ideas: a subset of the logic CTL for which
                 satisfaction is preserved under composition, and a
                 preorder on structures which captures the relation
                 between a component and a system containing the
                 component. Satisfaction of a formula in the logic
                 corresponds to being below a particular structure (a
                 tableau for the formula) in the preorder. We show how
                 to do assume-guarantee-style reasoning within this
                 framework. Additionally, we demonstrate efficient
                 methods for model checking in the logic and for
                 checking the preorder in several special cases. We have
                 implemented a system based on these methods, and we use
                 it to give a compositional verification of a CPU
                 controller.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Computer-aided software engineering (CASE).
                 {\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Decision tables. {\bf D.2.4}: Software,
                 SOFTWARE ENGINEERING, Program Verification. {\bf
                 F.1.1}: Theory of Computation, COMPUTATION BY ABSTRACT
                 DEVICES, Models of Computation, Relations among
                 models.",
}

@Article{Lamport:1994:TLA,
  author =       "Leslie Lamport",
  title =        "The Temporal Logic of Actions",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "872--923",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177726.html",
  abstract =     "The temporal logic of actions (TLA) is a logic for
                 specifying and reasoning about concurrent systems.
                 Systems and their properties are represented in the
                 same logic, so the assertion that a system meets its
                 specification and the assertion that one system
                 implements another are both expressed by logical
                 implication. TLA is very simple; its syntax and
                 complete formal semantics are summarized in about a
                 page. Yet, TLA is not just a logician's toy; it is
                 extremely powerful, both in principle and in practice.
                 This report introduces TLA and describes how it is used
                 to specify and verify concurrent algorithms. The use of
                 TLA to specify and reason about open systems will be
                 described elsewhere.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs.",
}

@Article{Broy:1994:AFC,
  author =       "Manfred Broy and Greg Nelson",
  title =        "Adding Fair Choice to {Dijkstra}'s Calculus",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "924--938",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177727.html",
  abstract =     "The paper studies the incorporation of a fair
                 nondeterministic choice operator into a generalization
                 of Dijkstra's calculus of guarded commands. The
                 generalization drops the law of the excluded miracle to
                 allow commands that correspond to partial relations.
                 Because of fairness, the new operator is not monotonic
                 for the orderings that are generally used for proving
                 the existence of least fixed points for recursive
                 definitions. To prove the existence of fixed points it
                 is necessary to consider several orderings at once, and
                 to restrict the class of recursive definitions.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Alternation and
                 nondeterminism.",
}

@Article{Afek:1994:BFF,
  author =       "Yehuda Afek and Danny Dolev and Eli Gafni and Michael
                 Merritt and Nir Shavit",
  title =        "A Bounded First-In, First-Enabled Solution to the $
                 \ell $-Exclusion Problem",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "939--953",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177731.html",
  abstract =     "This article presents a solution to the first-come,
                 first-enabled $ \ell $-exclusion problem of Fischer et
                 al. [1979]. Unlike their solution, this solution does
                 not use powerful read-modify-write synchronization
                 primitives and requires only bounded shared memory. Use
                 of the concurrent timestamp system of Dolev and Shavir
                 [1989] is key in solving the problem within bounded
                 shared memory.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; reliability",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Mutual exclusion.",
}

@Article{Joung:1994:CFO,
  author =       "Yuh-Jzer Joung and Scott A. Smolka",
  title =        "Coordinating First-Order Multiparty Interactions",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "954--985",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177739.html",
  abstract =     "A {\em first-order multiparty interaction\/} is an
                 abstraction mechanism that defines communication among
                 a set of {\em formal process roles}. Actual processes
                 participate in a first-order interaction by {\em
                 enroling\/} into roles, and execution of the
                 interaction can proceed when all roles are filled by
                 distinct processes. As in CSP, enrolement statements
                 can serve as guards in alternative commands. The {\em
                 enrolement guard-scheduling problem\/} then is to
                 enable the execution of first-order interactions
                 through the judicious scheduling of roles to processes
                 that are currently ready to execute enrolement
                 guards.\par

                 We present a fully distributed and message-efficient
                 algorithm for the enrolement guard-scheduling problem,
                 the first such solution of which we are aware. We also
                 describe several extensions of the algorithm,
                 including: {\em generic roles; dynamically changing
                 environments}, where processes can be created and
                 destroyed at run time; and {\em nested-enrolement},
                 which allows interactions to be nested.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Synchronization. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Scheduling. {\bf
                 D.1.3}: Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Concurrent
                 programming structures. {\bf D.4.4}: Software,
                 OPERATING SYSTEMS, Communications Management,
                 Input/Output. {\bf D.4.7}: Software, OPERATING SYSTEMS,
                 Organization and Design, Distributed systems.",
}

@Article{Reiter:1994:HSR,
  author =       "Michael K. Reiter and Kenneth P. Birman",
  title =        "How to Securely Replicate Services",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "986--1009",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177745.html",
  abstract =     "We present a method for constructing replicated
                 services that retain their availability and integrity
                 despite several servers and clients being corrupted by
                 an intruder, in addition to others failing benignly. We
                 also address the issue of maintaining a causal order
                 among client requests. We illustrate a security breach
                 resulting from an intruder's ability to effect a
                 violation of causality in the sequence of requests
                 processed by the service and propose an approach to
                 counter this attack. An important and novel feature of
                 our techniques is that the client need not be able to
                 identify or authenticate even a single server. Instead,
                 the client is required to possess only a single public
                 key for the service. We demonstrate the performance of
                 our techniques with a service we have implemented using
                 one of our protocols.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "reliability; security",
  subject =      "{\bf D.4.5}: Software, OPERATING SYSTEMS, Reliability,
                 Fault-tolerance. {\bf C.2.0}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS, General,
                 Security and protection. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems. {\bf D.4.5}: Software, OPERATING
                 SYSTEMS, Reliability, Fault-tolerance. {\bf D.4.6}:
                 Software, OPERATING SYSTEMS, Security and Protection,
                 Authentication. {\bf D.4.6}: Software, OPERATING
                 SYSTEMS, Security and Protection, Cryptographic
                 controls. {\bf K.6.5}: Computing Milieux, MANAGEMENT OF
                 COMPUTING AND INFORMATION SYSTEMS, Security and
                 Protection, Authentication.",
}

@Article{Heering:1994:LIP,
  author =       "J. Heering and P. Klint and J. Rekers",
  title =        "Lazy and Incremental Program Generation",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "1010--1023",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177750.html",
  abstract =     "Current program generators usually operate in a {\em
                 greedy\/} manner in the sense that a program must be
                 generated in its entirety before it can be used. If
                 generation time is scarce, or if the input to the
                 generator is subject to modification, it may be better
                 to be more cautious and to generate only those parts of
                 the program that are indispensable for processing the
                 particular data at hand. We call this {\em lazy program
                 generation}. Another, closely related strategy is {\em
                 incremental program generation}. When its input is
                 modified, an incremental generator will try to make a
                 corresponding modification in its output rather than
                 generate a completely new program. It may be
                 advantageous to use a combination of both strategies in
                 program generators that have to operate in a highly
                 dynamic and/or interactive environment.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance",
  subject =      "{\bf D.1.2}: Software, PROGRAMMING TECHNIQUES,
                 Automatic Programming. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Parsing. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators.",
}

@Article{Thorup:1994:CGA,
  author =       "Mikkel Thorup",
  title =        "Controlled Grammatic Ambiguity",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "1024--1050",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177759.html",
  abstract =     "A new approach to ambiguity of context-free grammars
                 is presented, and within this approach the LL and LR
                 techniques are generalized to solve the following
                 problems for large classes of ambiguous
                 grammars:\par

                 \begin{itemize} \item Construction of a parser that
                 accepts all sentences generated by the grammar, and
                 which always terminates in linear time.\par

                 \item Identification of the structural ambiguity: a
                 finite set of pairs of partial parse trees is
                 constructed; if for each pair the two partial parse
                 trees are semantically equivalent, the ambiguity of the
                 grammar is semantically irrelevant.\par

                 \end{itemize} The user may control the parser
                 generation so as to get a parser which finds some
                 specific parse trees for the sentences. The generalized
                 LL and LR techniques will still guarantee that the
                 resulting parser accepts all sentences and terminates
                 in linear time on all input.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages.",
}

@Article{Bates:1994:RSL,
  author =       "Joseph Bates and Alon Lavie",
  title =        "Recognizing Substrings of {LR$ (k) $} Languages in
                 Linear Time",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "3",
  pages =        "1051--1077",
  month =        may,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/177768.html",
  abstract =     "LR parsing techniques have long been studied as being
                 efficient and powerful methods for processing
                 context-free languages. A linear-time algorithm for
                 recognizing languages representable by LR(k) grammars
                 has long been known. Recognizing substrings of a
                 context-free language is at least as hard as
                 recognizing full strings of the language, since the
                 latter problem easily reduces to the former. In this
                 article we present a linear-time algorithm for
                 recognizing substrings of LR(k) languages, thus showing
                 that the substring recognition problem for these
                 languages is no harder than the full string recognition
                 problem. An interesting data structure, the
                 Forest-Structured Stack, allows the algorithm to track
                 all possible parses of a substring without loosing the
                 efficiency of the original LR parser. We present the
                 algorithm, prove its correctness, analyze its
                 complexity, and mention several applications that have
                 been constructed.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf F.4.2}: Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Grammars and Other Rewriting
                 Systems, Parsing. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Parsing.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Grammar types. {\bf F.4.3}:
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Formal Languages, Classes defined by
                 grammars or automata.",
}

@Article{Appel:1994:E,
  author =       "Andrew Appel and Charles Fischer",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1079--1079",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "Compiler/TOPLAS.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bossi:1994:TAP,
  author =       "Annalisa Bossi and Sandro Etalle",
  title =        "Transforming Acyclic Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1081--1096",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183434.html",
  abstract =     "An unfold/fold transformation system is a
                 source-to-source rewriting methodology devised to
                 improve the efficiency of a program. Any such
                 transformation should preserve the main properties of
                 the initial program: among them, termination. In the
                 field of logic programming, the class of acyclic
                 programs plays an important role in this respect, since
                 it is closely related to the one of terminating
                 programs. The two classes coincide when negation is not
                 allowed in the bodies of the clauses.\par

                 We prove that the Unfold/Fold transformation system
                 defined by Tamaki and Sato preserves the acyclicity of
                 the initial program. From this result, it follows that
                 when the transformation is applied to an acyclic
                 program, then the finite failure set for definite
                 programs is preserved; in the case of normal programs,
                 all major declarative and operational semantics are
                 preserved as well. These results cannot be extended to
                 the class of left-terminating programs without
                 modifying the definition of the transformation.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf F.4.1}: Theory
                 of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Logic programming. {\bf
                 I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf I.2.3}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Deduction and Theorem Proving,
                 Logic programming.",
}

@Article{Choi:1994:SSP,
  author =       "Jong-Deok Choi and Jeanne Ferrante",
  title =        "Static Slicing in the Presence of Goto Statements",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1097--1113",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183438.html",
  abstract =     "A static program slice is an extract of a program
                 which can help our understanding of the behavior of the
                 program; it has been proposed for use in debugging,
                 optimization, parallelization, and integration of
                 programs. This article considers two types of static
                 slices: executable and nonexecutable. Efficient and
                 well-founded methods have been developed to construct
                 executable slices for programs without goto statements;
                 it would be tempting to assume these methods would
                 apply as well in programs with arbitrary goto
                 statements. We show why previous methods do not work in
                 this more general setting, and describe our solutions
                 that correctly and efficiently compute executable
                 slices for programs even with arbitrary goto
                 statements. Our conclusion is that goto statements can
                 be accommodated in generating executable static
                 slices.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments.",
}

@Article{Wolfe:1994:DDD,
  author =       "Michael Wolfe",
  title =        "The Definition of Dependence Distance",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1114--1116",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183440.html",
  abstract =     "Several definitions of dependence distance can be
                 found in the literature. A single coherent definition
                 is the vector distance between the iteration vectors of
                 two iterations involved in a dependence relation.
                 Different ways to associate iteration vectors with
                 iterations can give different dependence distances to
                 the same program, and have different advantages.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Knoop:1994:OCM,
  author =       "Jens Knoop and Oliver {R{\"u}thing} and Bernhard
                 Steffen",
  title =        "Optimal Code Motion: Theory and Practice",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1117--1155",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183443.html",
  abstract =     "An implementation-oriented algorithm for {\em lazy
                 code motion\/} is presented that minimizes the number
                 of computations in programs while suppressing any
                 unnecessary code motion in order to avoid superfluous
                 register pressure. In particular, this variant of the
                 original algorithm for lazy code motion works on
                 flowgraphs whose nodes are basic blocks rather than
                 single statements, since this format is standard in
                 optimizing compilers. The theoretical foundations of
                 the modified algorithm are given in the first part,
                 where $t$-refined flowgraphs are introduced for
                 simplifying the treatment of flow graphs whose nodes
                 are basic blocks. The second part presents the ``basic
                 block'' algorithm in standard notation and gives
                 directions for its implementation in standard compiler
                 environments.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf F.2.2}: Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems.",
}

@Article{Freudenberger:1994:ASC,
  author =       "Stefan Freudenberger and Thomas R. Gross and P.
                 Geoffrey Lowney",
  title =        "Avoidance and Suppression of Compensation Code in a
                 Trace Scheduling Compiler",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1156--1214",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183446.html",
  abstract =     "Trace scheduling is an optimization technique that
                 selects a sequence of basic blocks as a trace and
                 schedules the operations from the trace together. If an
                 operation is moved across basic block boundaries, one
                 or more compensation copies may be required in the
                 off-trace code. This article discusses the generation
                 of compensation code in a trace scheduling compiler and
                 presents techniques for limiting the amount of
                 compensation code: avoidance (restricting code motion
                 so that no compensation code is required) and
                 suppression (analyzing the global flow of the program
                 to detect when a copy is redundant). We evaluate the
                 effectiveness of these techniques based on measurements
                 for the SPEC89 suite and the Livermore Fortran Kernels,
                 using our implementation of trace scheduling for a
                 Multiflow Trace 7/300. The article compares different
                 compiler models contrasting the performance of trace
                 scheduling with the performance obtained from typical
                 RISC compilation techniques.\par

                 There are two key results of this study. First, the
                 amount of compensation code generated is not large. For
                 the SPEC89 suite, the average code size increase due to
                 trace scheduling is 6\%. Avoidance is more important
                 than suppression, although there are some kernels that
                 benefit significantly from compensation code
                 suppression. Since compensation code is not a major
                 issue, a compiler can be more aggressive in code motion
                 and loop unrolling. Second, compensation code is not
                 critical to obtain the benefits of trace scheduling.
                 Our implementation of trace scheduling improves the
                 SPEC mark rating by 30\% over basic block scheduling,
                 but restricting trace scheduling so that no
                 compensation code is required improves the rating by
                 25\%. This indicates that most basic block scheduling
                 techniques can be extended to trace scheduling without
                 requiring any complicated compensation code
                 bookkeeping.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers.",
}

@Article{Hannan:1994:OSD,
  author =       "John Hannan",
  title =        "Operational Semantics-Directed Compilers and Machine
                 Architectures",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1215--1247",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183458.html",
  abstract =     "We consider the task of automatically constructing
                 intermediate-level machine architectures and compilers
                 generating code for these architectures, given
                 operational semantics for source languages. We use
                 operational semantics in the form of abstract machines
                 given by rewrite systems in which the rewrite rules
                 operate on terms representing states of computations.
                 To construct compilers and new architectures we employ
                 a particular strategy called pass separation, a form of
                 staging transformation, that takes a program $p$ and
                 constructs a pair of programs $ p_1, p_2$ such that $
                 p(x, y) = p_2 (p_1 (x), y)$ for all $ x, y$. If $p$
                 represents an operational semantics for a language,
                 with arguments $x$ and $y$ denoting a source program
                 and its input data, then pass separation constructs
                 programs $ p_1$ and $ p_2$ corresponding to a compiler
                 and an executor.\par

                 The compiler translates the source language into an
                 intermediate-level target language, and the executor
                 provides the definition for this language. Our use of
                 pass separation supports the automatic definition of
                 target languages or architectures, and the structure of
                 these architectures is directed by the structure of the
                 given source semantics. These architectures resemble
                 abstract machine languages found in hand-crafted
                 compilers. Our method is restricted to a limited class
                 of abstract machines given as term-rewriting systems,
                 but we argue that this class encompasses a large set of
                 language definitions derived from more natural
                 operational semantics. We provide two examples of our
                 method by constructing compilers and target
                 architectures for a simple functional language and a
                 simple imperative language. Though we construct these
                 architectures automatically, they bear a striking
                 resemblance to existing architectures constructed by
                 hand.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages,
                 Operational semantics.",
}

@Article{Pugh:1994:SAU,
  author =       "William Pugh and David Wonnacott",
  title =        "Static Analysis of Upper and Lower Bounds on
                 Dependences and Parallelism",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1248--1278",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183525.html",
  abstract =     "Existing compilers often fail to parallelize
                 sequential code, even when a program can be manually
                 transformed into parallel form by a sequence of
                 well-understood transformations (as in the case for
                 many of the Perfect Club Benchmark programs). These
                 failures can occur for several reasons: the code
                 transformations implemented in the compiler may not be
                 sufficient to produce parallel code, the compiler may
                 not find the proper sequence of transformations, or the
                 compiler may not be able to prove that one of the
                 necessary transformations is legal.\par

                 When a compiler fails to extract sufficient parallelism
                 from a program, the programmer may try to extract
                 additional parallelism. Unfortunately, the programmer
                 is typically left to search for parallelism without
                 significant assistance. The compiler generally does not
                 give feedback about which parts of the program might
                 contain additional parallelism, or about the types of
                 transformations that might be needed to realize this
                 parallelism. Standard program transformations and
                 dependence abstractions cannot be used to provide this
                 feedback.\par

                 In this paper, we propose a two-step approach to the
                 search for parallelism in sequential programs. In the
                 first step, we construct several sets of constraints
                 that describe, for each statement, which iterations of
                 that statement can be executed concurrently. By
                 constructing constraints that correspond to different
                 assumptions about which dependences might be eliminated
                 through additional analysis, transformations, and user
                 assertions, we can determine whether we can expose
                 parallelism by eliminating dependences. In the second
                 step of our search for parallelism, we examine these
                 constraint sets to identify the kinds of
                 transformations needed to exploit scalable parallelism.
                 Our tests will identify conditional parallelism and
                 parallelism that can be exposed by combinations of
                 transformations that reorder the iteration space (such
                 as loop interchange and loop peeling).\par

                 This approach lets us distinguish inherently sequential
                 code from code that contains unexploited parallelism.
                 It also produces information about the kinds of
                 transformations needed to parallelize the code, without
                 worrying about the order of application of the
                 transformations. Furthermore, when our dependence test
                 is inexact we can identify which unresolved dependences
                 inhibit parallelism by comparing the effects of
                 assuming dependence or independence. We are currently
                 exploring the use of this information in
                 programmer-assisted parallelization.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Ait-Kaci:1994:FPC,
  author =       "Hassan A{\"\i}t-Kaci and Andreas Podelski",
  title =        "Functions as Passive Constraints in {LIFE}",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1279--1318",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183526.html",
  abstract =     "LIFE is a programming language proposing to integrate
                 logic programming, functional programming, and
                 object-oriented programming. It replaces first-order
                 terms with [psi]-terms, data structures that allow
                 computing with partial information. These are
                 approximation structures denoting sets of values. LIFE
                 further enriches the expressiveness of [psi]-terms with
                 functional dependency constraints. We must explain the
                 meaning and use of functions in LIFE declaratively, as
                 solving partial information constraints. These
                 constraints do not attempt to generate their solutions
                 but behave as demons filtering out anything else. In
                 this manner, LIFE functions act as declarative
                 coroutines. We need to show that the [psi]-term's
                 approximation semantics is congruent with an
                 operational semantics viewing functional reduction as
                 an effective enforcing of passive constraints. In this
                 article, we develop a general formal framework for
                 entailment and disentailment of constraints based on a
                 technique called relative simplification. We study its
                 operational and semantical properties, and we use it to
                 account for functional application over [psi]-terms in
                 LIFE.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Syntax. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Concurrent,
                 distributed, and parallel languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nonprocedural languages. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Concurrent programming structures. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Coroutines. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Data types and structures. {\bf E.1}:
                 Data, DATA STRUCTURES, Graphs. {\bf E.1}: Data, DATA
                 STRUCTURES, Trees. {\bf D.1.0}: Software, PROGRAMMING
                 TECHNIQUES, General.",
}

@Article{Ball:1994:OPT,
  author =       "Thomas Ball and James R. Larus",
  title =        "Optimally Profiling and Tracing Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1319--1360",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183527.html",
  abstract =     "This paper describes algorithms for inserting
                 monitoring code to profile and trace programs. These
                 algorithms greatly reduce the cost of measuring
                 programs with respect to the commonly used technique of
                 placing code in each basic block. Program profiling
                 counts the number of times each basic block in a
                 program executes. Instruction tracing records the
                 sequence of basic blocks traversed in a program
                 execution. The algorithms optimize the placement of
                 counting/tracing code with respect to the expected or
                 measured frequency of each block or edge in a program's
                 control-flow graph. We have implemented the algorithms
                 in a profiling/tracing tool, and they substantially
                 reduce the overhead of profiling and tracing.\par

                 We also define and study the hierarchy of profiling
                 problems. These problems have two dimensions: what is
                 profiled (i.e., vertices (basic blocks) or edges in a
                 control-flow graph) and where the instrumentation code
                 is placed (in blocks or along edges). We compare the
                 optimal solutions to the profiling problems and
                 describe a new profiling problem: basic-block profiling
                 with edge counters. This problem is important because
                 an optimal solution to any other profiling problem (for
                 a given control-flow graph) is never better than an
                 optimal solution to this problem. Unfortunately,
                 finding an optimal placement of edge counters for
                 vertex profiling appears to be a hard problem in
                 general. However, our work shows that edge profiling
                 with edge counters works well in practice because it is
                 simple and efficient and finds optimal counter
                 placements in most cases. Furthermore, it yields more
                 information than a vertex profile. Tracing also
                 benefits from placing instrumentation code along edges
                 rather than on vertices.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; measurement",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Tracing. {\bf C.4}: Computer Systems
                 Organization, PERFORMANCE OF SYSTEMS, Measurement
                 techniques. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Programmer
                 workbench. {\bf D.2.5}: Software, SOFTWARE ENGINEERING,
                 Testing and Debugging, Diagnostics.",
}

@Article{Brogi:1994:MLP,
  author =       "Antonio Brogi and Paolo Mancarella and Dino Pedreschi
                 and Franco Turini",
  title =        "Modular Logic Programming",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "4",
  pages =        "1361--1398",
  month =        jul,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/183528.html",
  abstract =     "Modularity is a key issue in the design of modern
                 programming languages. When designing modular features
                 for declarative languages in general, and for logic
                 programming languages in particular, the challenge lies
                 in avoiding the superimposition of a complex syntactic
                 and semantic structure over the simple structure of the
                 basic language. The modular framework defined here for
                 logic programming consists of a small number of
                 operations over modules which are (meta-) logically
                 defined and semantically justified in terms of the
                 basic logic programming semantics. The operations enjoy
                 a number of algebraic properties, thus yielding an
                 algebra of modules. Despite its simplicity, the suite
                 of operations is shown capable of capturing the core
                 features of modularization: information hiding,
                 import/export relationships, and construction of module
                 hierarchies. A metalevel implementation and a
                 compilation-oriented implementation of the operations
                 are provided and proved sound with respect to the
                 semantics. The compilation-oriented implementation is
                 based on manipulation of name spaces and provides the
                 basis for an efficient implementation.",
  acknowledgement = ack-nhfb # " and " # ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques, Modules and
                 interfaces. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Modules,
                 packages. {\bf F.3.2}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Logic programming.",
}

@Article{Ball:1994:ECP,
  author =       "Thomas Ball",
  title =        "Efficiently Counting Program Events with Support for
                 On-Line Queries",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1399--1410",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186027.html",
  abstract =     "The ability to count events in a program's execution
                 is required by many program analysis applications. We
                 represent an instrumentation method for efficiently
                 counting events in a program's execution, with support
                 for on-line queries of the event count. Event counting
                 differs from basic block profiling in that an aggregate
                 count of events is kept rather than a set of counters.
                 Due to this difference, solutions to basic block
                 profiling are not well suited to event counting. Our
                 algorithm finds a subset of points in a program to
                 instrument, while guaranteeing that accurate event
                 counts can be obtained efficiently at every point in
                 the execution.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf C.4}: Computer Systems Organization, PERFORMANCE
                 OF SYSTEMS, Measurement techniques. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques.",
}

@Article{Laufer:1994:PTI,
  author =       "Konstantin L{\"a}ufer and Martin Odersky",
  title =        "Polymorphic Type Inference and Abstract Data Types",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1411--1430",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186031.html",
  abstract =     "Many statically typed programming languages provide an
                 abstract data type construct, such as the module in
                 Modula-2. However, in most of these languages,
                 implementations of abstract data types are not
                 first-class values. Thus, they cannot be assigned to
                 variables, passed as function parameters, or returned
                 as function results. Several higher-order functional
                 languages feature strong and static type systems,
                 parametric polymorphism, algebraic data types, and
                 explicit type variables. Most of them rely on
                 Hindley-Milner type inference instead of requiring
                 explicit type declarations for identifiers. Although
                 some of these languages support abstract data types, it
                 appears that none of them directly provides
                 light-weight abstract data types whose implementations
                 are first-class values. We show how to add significant
                 expressive power to statically typed functional
                 languages with explicit type variables by incorporating
                 first-class abstract types as an extension of algebraic
                 data types. Furthermore, we extend record types to
                 allow abstract components. The components of such
                 abstract records are selected using the dot notation.
                 Following Mitchell and Plotkin, we formalize abstract
                 types in terms of existentially quantified types. We
                 give a syntactically sound and complete type inference
                 algorithm and prove that our type system is
                 semantically sound with respect to standard
                 denotational semantics.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Modules, packages. {\bf
                 F.3.2}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Type structure. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf F.3.3}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs, Type structure.",
}

@Article{Ashley:1994:FCP,
  author =       "J. Michael Ashley and Charles Consel",
  title =        "Fixpoint Computation for Polyvariant Static Analyses
                 of Higher-Order Applicative Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1431--1448",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186037.html",
  abstract =     "This paper presents an optimized general-purpose
                 algorithm for polyvariant, static analyses of
                 higher-order applicative programs. A polyvariant
                 analysis is a very accurate form of analysis that
                 produces many more abstract descriptions for a program
                 than does a conventional analysis. It may also compute
                 intermediate abstract descriptions that are irrelevant
                 to the final result of the analysis. The optimized
                 algorithm addresses this overhead while preserving the
                 accuracy of the analysis. The algorithm is also
                 parameterized over both the abstract domain and degree
                 of polyvariance. We have implemented an instance of our
                 algorithm and evaluated its performance compared to the
                 unoptimized algorithm. Our implementation runs
                 significantly faster on average than the other
                 algorithm for benchmarks reported here.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing.",
}

@Article{Beemster:1994:SOG,
  author =       "Marcel Beemster",
  title =        "Strictness Optimization for Graph Reduction Machines
                 ({Why} id Might Not Be Strict)",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1449--1466",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186040.html",
  abstract =     "Strictness optimizations in the implementation of lazy
                 functional languages are not always valid. In
                 nonoptimized graph reduction, evaluation always takes
                 place at the request of case analysis or a primitive
                 operation. Hence, the result of a reduction is always a
                 data value and never a function. This implies that in
                 an implementation no argument satisfaction check is
                 required. But in the presence of strict arguments,
                 ``premature'' reduction may take place outside the
                 scope of a case or primitive operation. This causes
                 problems in graph reducers that use an {\em aggressive
                 take}. Two solutions are presented, one based on a
                 run-time argument satisfaction check, the other on a
                 weakened strictness analyzer. Experimental results are
                 used to compare the two solutions and show that the
                 cost of the aggressive take can be arbitrarily high for
                 specific programs. The experimental results enable a
                 trade-off to be made by the reduction machine
                 designer.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative languages. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Run-time
                 environments. {\bf F.1.1}: Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Models of Computation,
                 Relations among models.",
}

@Article{Ramalingam:1994:UA,
  author =       "G. Ramalingam",
  title =        "The Undecidability of Aliasing",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1467--1471",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186041.html",
  abstract =     "Alias analysis is a prerequisite for performing most
                 of the common program analyses such as
                 reaching-definitions analysis or live-variables
                 analysis. Landi [1992] recently established that it is
                 impossible to compute statically precise alias
                 information---either may-alias or must-alias---in
                 languages with if statements, loops, dynamic storage,
                 and recursive data structures: more precisely, he
                 showed that the may-alias relation is not recursive,
                 while the must-alias relation is not even recursively
                 enumerable. This article presents simpler proofs of the
                 same results.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 F.4.1}: Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Mathematical Logic, Computability
                 theory. {\bf F.4.3}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Formal
                 Languages, Decision problems. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Procedures, functions, and subroutines.",
}

@Article{Khedker:1994:GTB,
  author =       "Uday P. Khedker and Dhananjay M. Dhamdhere",
  title =        "A Generalized Theory of Bit Vector Data Flow
                 Analysis",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1472--1511",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186043.html",
  abstract =     "The classical theory of data flow analysis, which has
                 its roots in unidirectional flows, is inadequate to
                 characterize bidirectional data flow problems. We
                 present a generalized theory of bit vector data flow
                 analysis which explains the known results in
                 unidirectional and bidirectional data flows and
                 provides a deeper insight into the process of data flow
                 analysis. Based on the theory, we develop a
                 worklist-based generic algorithm which is uniformly
                 applicable to unidirectional and bidirectional data
                 flow problems. It is simple, versatile, and easy to
                 adapt for a specific problem. We show that the theory
                 and the algorithm are applicable to all bounded
                 monotone data flow problems which possess the property
                 of the separability of solution.\par

                 The theory yields valuable information about the
                 complexity of data flow analysis. We show that the
                 complexity of worklist-based iterative analysis is the
                 same for unidirectional and bidirectional problems. We
                 also define a measure of the complexity of round-robin
                 iterative analysis. This measure, called {\em width},
                 is uniformly applicable to unidirectional and
                 bidirectional problems and provides a tighter bound for
                 unidirectional problems than the traditional measure of
                 {\em depth}. Other applications include explanation of
                 isolated results in efficient solution techniques and
                 motivation of new techniques for bidirectional flows.
                 In particular, we discuss edge splitting and edge
                 placement and develop a feasibility criterion for
                 decomposition of a bidirectional flow into a sequence
                 of unidirectional flows.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf F.2.2}: Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems,
                 Complexity of proof procedures. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Clarke:1994:MCA,
  author =       "Edmund M. Clarke and Orna Grumberg and David E. Long",
  title =        "Model Checking and Abstraction",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1512--1542",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186051.html",
  abstract =     "We describe a method for using abstraction to reduce
                 the complexity of temporal-logic model checking. Using
                 techniques similar to those involved in abstract
                 interpretation, we construct an abstract model of a
                 program without ever examining the corresponding
                 unabstracted model. We show how this abstract model can
                 be used to verify properties of the original program.
                 We have implemented a system based on these techniques,
                 and we demonstrate their practicality using a number of
                 examples, including a program representing a pipelined
                 ALU circuit with over $ 10^{1300} $ states.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 B.5.2}: Hardware, REGISTER-TRANSFER-LEVEL
                 IMPLEMENTATION, Design Aids, Verification. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory.",
}

@Article{Abadi:1994:OFR,
  author =       "Mart{\'\i}n Abadi and Leslie Lamport",
  title =        "An Old-Fashioned Recipe for Real Time",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1543--1571",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186058.html",
  abstract =     "Traditional methods for specifying and reasoning about
                 concurrent systems work for real-time systems. Using
                 TLA (the temporal logic of actions), we illustrate how
                 they work with the examples of a queue and of a
                 mutual-exclusion protocol. In general, two problems
                 must be addressed: avoiding the real-time programming
                 version of Zeno's paradox, and coping with
                 circularities when composing real-time
                 assumption/guarantee specifications. Their solutions
                 rest on properties of machine closure and
                 realizability.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs.",
}

@Article{Micallef:1994:EAG,
  author =       "Josephine Micallef and Gail E. Kaiser",
  title =        "Extending Attribute Grammers to Support
                 Programming-in-the-Large",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1572--1612",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186091.html",
  abstract =     "Attribute grammars add specification of static
                 semantic properties to context-free grammars, which, in
                 turn, describe the syntactic structure of program
                 units. However, context-free grammars cannot express
                 programming-in-the-large features common in modern
                 programming languages, including unordered collections
                 of units, included units, and sharing of included
                 units. We present extensions to context-free grammars,
                 and corresponding extensions to attribute grammars,
                 suitable for defining such features. We explain how
                 batch and incremental attribute-evaluation algorithms
                 can be adapted to support these extensions, resulting
                 in a uniform approach to intraunit and interunit static
                 semantic analysis and translation of multiunit
                 programs.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.2.6}: Software, SOFTWARE ENGINEERING,
                 Programming Environments, Interactive. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Syntax. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Modules, packages. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Translator writing systems and compiler generators.
                 {\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.2.3}:
                 Software, SOFTWARE ENGINEERING, Coding. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, GRAMPS.",
}

@Article{Breuer:1994:DET,
  author =       "Peter T. Breuer and Jonathan P. Bowen",
  title =        "Decompilation: The Enumeration of Types and Grammers",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1613--1647",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186093.html",
  abstract =     "While a compiler produces low-level object code from
                 high-level source code, a decompiler produces
                 high-level code from low-level code and has
                 applications in the testing and validation of
                 safety-critical software. The decompilation of an
                 object code provides an independent demonstration of
                 correctness that is hard to better for industrial
                 purposes (an alternative is to prove the compiler
                 correct). But, although compiler compilers are in
                 common use in the software industry, a decompiler
                 compiler is much more unusual.\par

                 It turns out that a data type specification for a
                 programming-language grammar can be remolded into a
                 functional program that enumerates all of the abstract
                 syntax trees of the grammar. This observation is the
                 springboard for a general method for compiling
                 decompilers from the specifications of (nonoptimizing)
                 compilers.\par

                 This paper deals with methods and theory, together with
                 an application of the technique. The correctness of a
                 decompiler generated from a simple occam-like compiler
                 specification is demonstrated. The basic problem of
                 enumerating the syntax trees of grammars, and then
                 stopping, is shown to have no recursive solution, but
                 methods of abstract interpretation can be used to
                 guarantee the adequacy and completeness of our
                 technique in practical instances, including the
                 decompiler for the language presented here.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf F.4.3}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Formal
                 Languages, Operations on languages. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming. {\bf D.1.6}: Software,
                 PROGRAMMING TECHNIQUES, Logic Programming. {\bf D.3.1}:
                 Software, PROGRAMMING LANGUAGES, Formal Definitions and
                 Theory, Semantics. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Syntax.",
}

@Article{Whalley:1994:AIC,
  author =       "David B. Whalley",
  title =        "Automatic Isolation of Compiler Errors",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "5",
  pages =        "1648--1659",
  month =        sep,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/186103.html",
  abstract =     "This paper describes a tool called {\em vpoiso\/} that
                 was developed to isolate errors automatically in the
                 {\em vpo\/} compiler system. The two general types of
                 compiler errors isolated by this tool are optimization
                 and nonoptimization errors. When isolating optimization
                 errors, {\em vpoiso\/} relies on the {\em vpo\/}
                 optimizer to identify sequences of changes, referred to
                 as transformations, that result in semantically
                 equivalent code and to provide the ability to stop
                 performing {\em improving\/} (or unnecessary)
                 transformations after a specified number have been
                 performed. A compilation of a typical program by {\em
                 vpo\/} often results in thousands of {\em improving\/}
                 transformations being performed. The {\em vpoiso\/}
                 tool can automatically isolate the first {\em
                 improving\/} transformation that causes incorrect
                 output of the execution of the compiled programs by
                 using a binary search that varies the number of {\em
                 improving\/} transformation performed. Not only is the
                 illegal transformation automatically isolated, but {\em
                 vpoiso\/} also identifies the location and instant the
                 transformation is performed in {\em vpo}.
                 Nonoptimization errors occur from problems in the front
                 end, code generator, and {\em necessary\/}
                 transformations in the optimizer. If another compiler
                 is available that can produce correct (but perhaps more
                 inefficient) code, then {\em vpoiso\/} can isolate
                 nonoptimization errors to a single function. Automatic
                 isolation of compiler errors facilitates retargeting a
                 compiler to a new machine, maintenance of the compiler,
                 and supporting experimentation with new
                 optimizations.",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Zic:1994:TCB,
  author =       "J. J. {\v{Z}}ic",
  title =        "Time-Constrained Buffer Specifications in {CSP+T} and
                 Timed {CSP}",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1661--1674",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197322.html",
  abstract =     "A finite buffer with time constraints on the rate of
                 accepting inputs, producing outputs, and message
                 latency is specified using both Timed CSP and a new
                 real-time specification language, CSP + T, which adds
                 expressive power to some of the sequential aspects of
                 CSP and allows the description of complex event timings
                 from within a single sequential process. On the other
                 hand, Timed CSP encourages event-timing descriptions to
                 be built up in a constraint-oriented manner with the
                 parallel composition of several processes. Although
                 these represent two complementary specification styles,
                 both provide valuable insights into the specification
                 of complex event timings.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; performance",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Languages. {\bf B.4.4}:
                 Hardware, INPUT/OUTPUT AND DATA COMMUNICATIONS,
                 Performance Analysis and Design Aids, Formal models.",
}

@Article{Bohm:1994:TIP,
  author =       "A. P. W. B{\"o}hm and R. R. Oldehoeft",
  title =        "Two Issues in Parallel Language Design",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1675--1683",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197325.html",
  abstract =     "In this article, we discuss two programming language
                 features that have value for expressibility and
                 efficiency: nonstrictness and nondeterminism. Our work
                 arose while assessing ways to enhance a currently
                 successful language, SISAL [McGraw et al. 1985]. The
                 questions of how best to include these features, if at
                 all, has led not to conclusions but to an impetus to
                 explore the answers in an objective way. We will retain
                 strictness for efficiency reasons and explore the
                 limits it may impose, and we will experiment with a
                 carefully controlled form of nondeterminism to assess
                 its expressive power.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, SISAL. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Concurrent, distributed, and parallel languages. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures.",
}

@Article{Brandis:1994:SPG,
  author =       "M. M. Brandis and H. Moessenboeck",
  title =        "Single-Pass Generation of Static Single-Assignment
                 Form for Structured Languages",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1684--1698",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197331.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Code generation. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf E.1}: Data, DATA STRUCTURES,
                 Trees.",
}

@Article{Appel:1994:ABG,
  author =       "A. W. Appel",
  title =        "Axiomatic Bootstrapping: a Guide for Compiler
                 Hackers",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1699--1718",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197336.html",
  abstract =     "If a compiler for language $L$ is implemented in $L$,
                 then it should be able to compile itself. But for
                 systems used interactively commands are compiled and
                 immediately executed, and these commands may invoke the
                 compiler; so there is the question of how ever to
                 cross-compile for another architecture. Also, where the
                 compiler writes binary files of static type information
                 that must then be read in by the bootstrapped
                 interactive compiler, how can one ever change the
                 format of digested type information in binary
                 files?\par

                 Here I attempt an axiomatic clarification of the
                 bootstrapping technique, using {\em Standard ML of New
                 Jersey\/} as a case study. This should be useful to
                 implementors of any self-applicable interactive
                 compiler with nontrivial object-file and runtime-system
                 compatibility problems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "verification",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments, Interactive. {\bf D.4.9}: Software,
                 OPERATING SYSTEMS, Systems Programs and Utilities,
                 Linkers. {\bf D.4.9}: Software, OPERATING SYSTEMS,
                 Systems Programs and Utilities, Loaders.",
}

@Article{Haines:1994:CFC,
  author =       "N. Haines and D. Kindred and J. G. Morrisett and S. M.
                 Nettles",
  title =        "Composing First-Class Transactions",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1719--1736",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197346.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; reliability",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Modules, packages. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Procedures, functions, and subroutines. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Mutual
                 exclusion. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Synchronization. {\bf D.4.5}:
                 Software, OPERATING SYSTEMS, Reliability,
                 Fault-tolerance.",
}

@Article{Misra:1994:PSP,
  author =       "J. Misra",
  title =        "Powerlist: a Structure for Parallel Recursion",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1737--1767",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197356.html",
  abstract =     "Many data-parallel algorithms---Fast Fourier
                 Transform, Batcher's sorting schemes, and the
                 prefix-sum---exhibit recursive structure. We propose a
                 data structure called {\em powerlist\/} that permits
                 succinct descriptions of such algorithms, highlighting
                 the roles of both parallelism and recursion. Simple
                 algebraic properties of this data structure can be
                 exploited to derive properties of these algorithms and
                 to establish equivalence of different algorithms that
                 solve the same problem.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Recursion.
                 {\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Parallel programming.",
}

@Article{Carr:1994:IRM,
  author =       "S. Carr and K. Kennedy",
  title =        "Improving the Ratio of Memory Operations in
                 Floating-Point Operations in Loops",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1768--1810",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197366.html",
  abstract =     "Over the past decade, microprocessor design strategies
                 have focused on increasing the computational power on a
                 single chip. Because computations often require more
                 data from cache per floating-point operation than a
                 machine can deliver and because operations are
                 pipelined, idle computational cycles are common when
                 scientific applications are executed. To overcome these
                 bottlenecks, programmers have learned to use a coding
                 style that ensures a better balance between memory
                 references and floating-point operations. In our view,
                 this is a step in the wrong direction because it makes
                 programs more machine-specific. A programmer should not
                 be required to write a new program version for each new
                 machine; instead, the task of specializing a program to
                 a target machine should be left to the
                 compiler.\par

                 But is our view practical? Can a sophisticated
                 optimizing compiler obviate the need for the myriad of
                 programming tricks that have found their way into
                 practice to improve the performance of the memory
                 hierarchy? In this paper we attempt to answer that
                 question. To do so, we develop and evaluate techniques
                 that automatically restructure program loops to achieve
                 high performance on specific target architectures.
                 These methods attempt to balance computation and memory
                 accesses and seek to eliminate or reduce pipeline
                 interlock. To do this, they estimate statically the
                 balance between memory operations and floating-point
                 operations for each loop in a particular program and
                 use these estimates to determine whether to apply
                 various loop transformations.\par

                 Experiments with our automatic techniques show that
                 integer-factor speedups are possible on kernels.
                 Additionally, the estimate of the balance between
                 memory operations and computation, and the application
                 of the estimate are very accurate---experiments reveal
                 little difference between the balance achieved by our
                 automatic system that is made possible by hand
                 optimization.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Liskov:1994:BNS,
  author =       "B. H. Liskov and J. M. Wing",
  title =        "A Behavioral Notion of Subtyping",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1811--1841",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197383.html",
  abstract =     "The use of hierarchy is an important component of
                 object-oriented design. Hierarchy allows the use of
                 type families, in which higher level supertypes capture
                 the behavior that all of their subtypes have in common.
                 For this methodology to be effective, it is necessary
                 to have a clear understanding of how subtypes and
                 supertypes are related. This paper takes the position
                 that the relationship should ensure that any property
                 proved about supertype objects also holds for its
                 subtype objects. It presents two ways of defining the
                 subtype relation, each of which meets this criterion,
                 and each of which is easy for programmers to use. The
                 subtype relation is based on the specifications of the
                 sub- and supertypes; the paper presents a way of
                 specifying types that makes it convenient to define the
                 subtype relation. The paper also discusses the
                 ramifications of this notion of subtyping on the design
                 of type families.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; verification",
  subject =      "{\bf D.2.1}: Software, SOFTWARE ENGINEERING,
                 Requirements/Specifications, Methodologies. {\bf
                 D.1.5}: Software, PROGRAMMING TECHNIQUES,
                 Object-oriented Programming. {\bf D.2.1}: Software,
                 SOFTWARE ENGINEERING, Requirements/Specifications,
                 Languages. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Invariants. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Type structure.",
}

@Article{VonBank:1994:UMP,
  author =       "D. G. {Von Bank} and C. M. Shub and R. W. Sebesta",
  title =        "A Unified Model of Pointwise Equivalence of Procedural
                 Computations",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1842--1874",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:59:06 1998",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197402.html",
  abstract =     "The execution of a program on a processor is viewed as
                 a representation of that program going through a
                 sequence of states. Each state change is manifested by
                 the execution of a single instruction. Models that
                 depend on this perspective are presented. The first is
                 a static model of a description of a procedural
                 computation. This model formalizes the description of
                 the information in an executable module. Following this
                 dynamic model of a procedural computation is given.
                 This second model describes how a computation
                 transitions from state to state and how the states of a
                 computation are represented. Next, the state of a
                 procedural computation is defined at certain
                 well-defined points in its progression. These points
                 represent potential points of correspondence to another
                 instance of the computation. Then, the equivalence of
                 these well-defined computation states is described.
                 This refinement eliminates the nonmatching potential
                 correspondences. The remaining points describe where
                 the two computations are in the same state. These are
                 precisely the points of equivalence of procedural
                 computations. This final model of pointwise equivalence
                 can be applied to the problem of migrating a
                 computation from one processor to another (possibly
                 architecturally dissimilar) processor.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf F.1.1}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Models of
                 Computation, Relations among models. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques.",
}

@Article{Berzins:1994:SMS,
  author =       "V. Berzins",
  title =        "Software Merge: Semantics of Combining Changes to
                 Programs",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1875--1903",
  month =        nov,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/197403.html",
  abstract =     "We present a language-independent semantic model of
                 the process of combining changes to programs. This
                 model extends the domains used in denotational
                 semantics (complete partial orders) to Boolean
                 algebras, and represents incompatible modifications as
                 well as compatible extensions. The model is used to
                 define the intended semantics of change-merging
                 operations on programs and to establish some general
                 properties of software merging. We determine conditions
                 under which changes to subprograms of a software system
                 can be merged independently and illustrate cases where
                 this is not possible.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Denotational semantics. {\bf D.2.7}:
                 Software, SOFTWARE ENGINEERING, Distribution and
                 Maintenance, Enhancement. {\bf D.2.7}: Software,
                 SOFTWARE ENGINEERING, Distribution and Maintenance,
                 Version control. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 modification. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 synthesis. {\bf I.2.2}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 transformation.",
}

@Article{Anonymous:1994:AI,
  author =       "Anonymous",
  title =        "1994 Author Index",
  journal =      j-TOPLAS,
  volume =       "16",
  number =       "6",
  pages =        "1904--1907",
  month =        oct,
  year =         "1994",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:21:36 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Larcheveque:1995:OIP,
  author =       "J.-M. Larchev{\^e}que",
  title =        "Optimal Incremental Parsing",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "1--15",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/200996.html",
  abstract =     "This communication sets the problem of incremental
                 parsing in the context of a complete incremental
                 compiling system. It turns out that, according to the
                 incrementally paradigm of the attribute evaluator and
                 data-flow analyzer to be used, two definitions of
                 optimal incrementality in a parser are possible.
                 Algorithms for achieving both forms of optimality are
                 given, both of them based on ordinary LALR(1) parse
                 tables. Optimality and correctness proofs, which are
                 merely outlined in this communication, are made
                 intuitive thanks to the concept of a {\em well-formed
                 list of threaded trees}, a natural extension of the
                 concept of {\em threaded tree\/} found in earlier works
                 on incremental parsing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments, Interactive.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf E.1}: Data, DATA
                 STRUCTURES, Trees.",
}

@Article{Tsay:1995:DFP,
  author =       "Yih-Kuen Tsay and Rajive L. Bagrodia",
  title =        "Deducing Fairness Properties in {UNITY} Logic --- a
                 New Completeness Result",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "16--27",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/200997.html",
  abstract =     "We explore the use of UNITY logic in specifying and
                 verifying fairness properties of UNITY and UNITY-like
                 programs whose semantics can be modeled by weakly fair
                 transition systems. For such programs, strong fairness
                 properties in the form of ``if $p$ holds infinitely
                 often then $q$ also holds infinitely often $ \Box
                 \Diamond p \mapsto \Box \Diamond q$, can be expressed
                 as conditional UNITY properties of the form of
                 ``Hypothesis: {\em true\/} $ \mapsto p$ Conclusion:
                 {\em true\/} $ \mapsto q$''. We show that UNITY logic
                 is relatively complete for proving such properties; in
                 the process, a simple inference rule is derived.
                 Specification and verification of weak fairness
                 properties are also discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs.",
}

@Article{Codish:1995:IAI,
  author =       "Michael Codish and Anne Mulkers and Maurice Bruynooghe
                 and Maria Garcia de la Banda and Manuel Hermenegildo",
  title =        "Improving Abstract Interpretations by Combining
                 Domains",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "28--44",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/200998.html",
  abstract =     "This article considers static analysis based on
                 abstract interpretation of logic programs over combined
                 domains. It is known that analyses over combined
                 domains provide more information potentially than
                 obtained by the independent analyses. However, the
                 construction of a combined analysis often requires
                 redefining the basic operations for the combined
                 domain. A practical approach to maintain precision in
                 combined analyses of logic programs which reuses the
                 individual analyses and does not redefine the basic
                 operations is illustrated. The advantages of the
                 approach are that (1) proofs of correctness for the new
                 domains are not required and (2) implementations can be
                 reused. The approach is demonstrated by showing that a
                 combined sharing analysis---constructed from ``old''
                 proposals---compares well with other ``new'' proposals
                 suggested in recent literature both from the point of
                 view of efficiency and accuracy.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf F.3.1}: Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Assertions. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Invariants.",
}

@Article{Skudlarek:1995:NMI,
  author =       "Joseph P. Skudlarek",
  title =        "Notes on ``{A Methodology for Implementing Highly
                 Concurrent Data Objects}''",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "45--46",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/200999.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory",
  subject =      "{\bf D.1.0}: Software, PROGRAMMING TECHNIQUES,
                 General.",
}

@Article{Palsberg:1995:CAC,
  author =       "Jens Palsberg",
  title =        "Closure Analysis in Constraint Form",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "47--62",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201001.html",
  abstract =     "Flow analyses of untyped higher-order functional
                 programs have in the past decade been presented by
                 Ayers, Bondorf, Consel, Jones, Heintze, Sestoft,
                 Shivers, Steckler, Wand, and others. The analyses are
                 usually defined as abstract interpretations and are
                 used for rather different tasks such as type recovery,
                 globalization, and binding-time analysis. The analyses
                 all contain a global {\em closure analysis\/} that
                 computes information about higher-order control-flow.
                 Sestoft proved in 1989 and 1991 that closure analysis
                 is correct with respect to call-by-name and
                 call-by-value semantics, but it remained open if
                 correctness holds for arbitrary
                 beta-reduction.\par

                 This article answers the question; both closure
                 analysis and others are correct with respect to
                 arbitrary beta-reduction. We also prove a
                 subject-reduction result: closure information is still
                 valid after beta-reduction. The core of our proof
                 technique is to define closure analysis using a
                 constraint system. The constraint system is equivalent
                 to the closure analysis of Bondorf, which in turn is
                 based on Sestoft's.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf F.3.1}:
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Logics of programs. {\bf F.4.3}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Formal
                 Languages, Operations on languages. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Operational
                 semantics. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Optimization.",
}

@Article{Aiken:1995:SST,
  author =       "Alexander Aiken and John H. Williams and Edward L.
                 Wimmers",
  title =        "Safe: a Semantic Technique for Transforming Programs
                 in the Presence of Errors",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "63--84",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201002.html",
  abstract =     "Language designers and implementors have avoided
                 specifying and preserving the meaning of programs that
                 produce errors. This is apparently because being forced
                 to preserve error behavior limits severely the scope of
                 program optimization, even for correct programs.
                 However, error behavior preservation is desirable for
                 debugging, and error behavior must be preserved in any
                 language that permits user-generated errors (i.e.,
                 exceptions).\par

                 This article presents a technique for expressing
                 general program transformations for languages that
                 possess a rich collection of distinguishable error
                 values. This is accomplished by defining a higher-order
                 function called {\bf Safe}, which can be used to
                 annotate those portions of a program that are
                 guaranteed not to produce errors. It is shown that this
                 facilitates the expression of very general program
                 transformations, effectively giving program
                 transformations in a language with many error values
                 the same power and generality as program
                 transformations in a language with only a single error
                 value.\par

                 Using the semantic properties of {\bf Safe}, it is
                 possible to provide some useful sufficient conditions
                 for establishing the correctness of transformations in
                 the presence of errors. In particular, a
                 Substitutability theorem is proven, which can be used
                 to justify ``in-context'' optimizations:
                 transformations that alter the meanings of
                 subexpressions without changing the meaning of the
                 whole program. Finally, the effectiveness of the
                 technique is demonstrated by some examples of its use
                 in an optimizing compiler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics.",
}

@Article{Gerlek:1995:BIV,
  author =       "Michael P. Gerlek and Eric Stoltz and Michael Wolfe",
  title =        "Beyond Induction Variables: Detecting and Classifying
                 Sequences Using a Demand-Driven {SSA} Form",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "85--122",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201003.html",
  abstract =     "Linear induction variable detection is usually
                 associated with the strength reduction optimization.
                 For restructuring compilers, effective data dependence
                 analysis requires that the compiler detect and
                 accurately describe linear and nonlinear induction
                 variables as well as more general sequences. In this
                 article we present a practical technique for detecting
                 a broader class of linear induction variables than is
                 usually recognized, as well as several other sequence
                 forms, including periodic, polynomial, geometric,
                 monotonic, and wrap-around variables. Our method is
                 based on Factored Use-Def (FUD) chains, a demand-driven
                 representation of the popular Static Single Assignment
                 (SSA) form. In this form, strongly connected components
                 of the associated SSA graph correspond to sequences in
                 the source program: we describe a simple yet efficient
                 algorithm for detecting and classifying these
                 sequences. We have implemented this algorithm in
                 Nascent, our restructuring Fortran 90+ compiler, and we
                 present some results showing the effectiveness of our
                 approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Chatterjee:1995:OEA,
  author =       "Siddhartha Chatterjee and John R. Gilbert and Robert
                 Schreiber and Shang-Hua Teng",
  title =        "Optimal Evaluation of Array Expressions on Massively
                 Parallel Machines",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "123--156",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201004.html",
  abstract =     "We investigate the problem of evaluating Fortran
                 90-style array expressions on massively parallel
                 distributed-memory machines. On such a machine, an
                 elementwise operation can be performed in constant time
                 for arrays whose corresponding elements are in the same
                 processor. If the arrays are not aligned in this
                 manner, the cost of aligning them is part of the cost
                 of evaluating the expression tree. The choice of where
                 to perform the operation then affects this cost.\par

                 We describe the communication cost of the parallel
                 machine theoretically as a metric space; we model the
                 alignment problem as that of finding a minimum-cost
                 embedding of the expression tree into this space. We
                 present algorithms based on dynamic programming that
                 solve the embedding problem optimally for several
                 communication cost metrics: multidimensional grids and
                 rings, hypercubes, fat-trees, and the discrete metric.
                 We also extend our approach to handle operations that
                 change the shape of the arrays.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf C.1.2}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors), Interconnection architectures. {\bf
                 C.1.2}: Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors), Single-instruction-stream,
                 multiple-data-stream processors (SIMD). {\bf C.1.2}:
                 Computer Systems Organization, PROCESSOR ARCHITECTURES,
                 Multiple Data Stream Architectures (Multiprocessors),
                 Multiple-instruction-stream, multiple-data-stream
                 processors (MIMD). {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf E.1}: Data, DATA STRUCTURES, Arrays.
                 {\bf G.2.2}: Mathematics of Computing, DISCRETE
                 MATHEMATICS, Graph Theory, Trees.",
}

@Article{Charron-Bost:1995:LTP,
  author =       "Bernadette Charron-Bost and Carole Delporte-Gallet and
                 Hugues Fauconnier",
  title =        "Local and Temporal Predicates in Distributed Systems",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "157--179",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201005.html",
  abstract =     "The definitions of the predicates Possibly $ \phi $
                 and Definitely $ \phi $, where $ \phi $ is a global
                 predicate of a distributed computation, lead to the
                 definitions of two predicate transformers $p$ and $D$.
                 We show that $p$ plays the same role with respect to
                 {\em time\/} as the predicate transformers $ K_i$ in
                 knowledge theory play with respect to {\em space}.
                 Pursuing this analogy, we prove that local predicates
                 are exactly the fixed points of the $ K_i$'s while the
                 stable predicates are the fixed points of p. In terms
                 of the predicate transformers $p$ and $D$, we define a
                 new class of predicates that we call {\em
                 observer-independent\/} predicates and for which the
                 detection of Possibly $ \phi $ and Definitely $ \phi $
                 is quite easy. Finally, we establish a temporal
                 counterpart to the knowledge change theorem of Chandy
                 and Misra which formally proves that the global view of
                 a distributed system provided by its various
                 observations does not differ too much from its truth
                 behavior.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf C.2.4}:
                 Computer Systems Organization, COMPUTER-COMMUNICATION
                 NETWORKS, Distributed Systems, Distributed
                 applications. {\bf D.2.4}: Software, SOFTWARE
                 ENGINEERING, Program Verification, Assertion checkers.
                 {\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids.",
}

@Article{Qian:1995:CRO,
  author =       "Xiaolei Qian and Allen Goldberg",
  title =        "Corrigendum: ``{Referential Opacity in
                 Nondeterministic Data Refinement}''",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "1",
  pages =        "180--180",
  month =        jan,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 11:28:41 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See {\em ACM Lett. Program. Lang. Syst.} 2, 1--4
                 (Mar.--Dec. 1993), 233--241.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Click:1995:CAC,
  author =       "Cliff Click and Keith D. Cooper",
  title =        "Combining Analyses, Combining Optimizations",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "181--196",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201061.html",
  abstract =     "Modern optimizing compilers use several passes over a
                 program's intermediate representation to generate good
                 code. Many of these optimizations exhibit a
                 phase-ordering problem. Getting the best code may
                 require iterating optimizations until a fixed point is
                 reached. Combining these phases can lead to the
                 discovery of more facts about the program, exposing
                 more opportunities for optimization. This article
                 presents a framework for describing optimizations. It
                 shows how to combine two such frameworks and how to
                 reason about the properties of the resulting framework.
                 The structure of the frame work provides insight into
                 when a combination yields better results. To make the
                 ideas more concrete, this article presents a framework
                 for combining constant propagation, value numbering,
                 and unreachable-code elimination. It is an open
                 question as to what other frameworks can be combined in
                 this way.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Venkatesh:1995:ERD,
  author =       "G. A. Venkatesh",
  title =        "Experimental Results from Dynamic Slicing of {C}
                 Programs",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "197--216",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201062.html",
  abstract =     "{\em Program slicing\/} is a program analysis
                 technique that has been studied in the context of
                 several different applications in the construction,
                 optimization, maintenance, testing, and debugging of
                 programs. Algorithms are available for constructing
                 slices for a particular execution of a program (dynamic
                 slices), as well as to approximate a subset of the
                 behavior over all possible executions of a program
                 (static slices). However, these algorithms have been
                 studied only in the context of small abstract
                 languages. Program slicing is bound to remain an
                 academic exercise unless one can not only demonstrate
                 the feasibility of building a slicer for nontrivial
                 programs written in a real programming language, but
                 also verify that a type of slice is sufficiently thin,
                 on the average, for the application for which it is
                 chosen. In this article, we present results from using
                 {\em SLICE}, a dynamic program slicer for C programs,
                 designed and implemented to experiment with several
                 different kinds of program slices and to study them
                 both qualitatively and quantitatively. Several
                 application programs, ranging in size (i.e., number of
                 lines of code) over two orders of magnitude, were
                 sliced exhaustively to obtain average worst-case
                 metrics for the size of program slices.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages; performance",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments,
                 Interactive. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Chin:1995:ROA,
  author =       "Wei-Ngan Chin and Eak-Khoon Goh",
  title =        "A Reexamination of ``{Optimization of Array Subscript
                 Range Checks''}",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "217--227",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201063.html",
  abstract =     "Jonathan Asuru proposed recently an enhanced method
                 for optimizing array subscript range checks. The
                 proposed method is however unsafe and may generate
                 optimized programs whose behavior is different from the
                 original program. Two main flaws in Asuru's method are
                 described, together with suggested remedies and
                 improvements.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; reliability",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.5}: Software, SOFTWARE
                 ENGINEERING, Testing and Debugging, Error handling and
                 recovery. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization.",
}

@Article{Wu:1995:WCC,
  author =       "Pei-Chi Wu and Feng-Jian Wang",
  title =        "A Worst Case of Circularity Test Algorithms for
                 Attribute Grammars",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "228--232",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201064.html",
  abstract =     "Although the circularity test problem for {\em
                 attribute grammars\/} (AGs) has been proven to be
                 intrinsically exponential, to date, a worst case for
                 the existing circularity test algorithms has yet to be
                 presented. This note presents a worst-case AG in which
                 the number of incomparable dependency graphs induced at
                 the root is exponential. The worst case can help to
                 clarify the complexity of the problem.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems, Decision problems.",
}

@Article{Rogers:1995:SDD,
  author =       "Anne Rogers and Martin C. Carlisle and John H. Reppy
                 and L. J. Hendren",
  title =        "Supporting Dynamic Data Structures on
                 Distributed-Memory Machines",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "233--263",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201065.html",
  abstract =     "Compiling for distributed-memory machines has been a
                 very active research area in recent years. Much of this
                 work has concentrated on programs that use arrays as
                 their primary data structures. To date, little work has
                 been done to address the problem of supporting programs
                 that use pointer-based dynamic data structures. The
                 techniques developed for supporting SPMD execution of
                 array-based programs rely on the fact that arrays are
                 statically defined and directly addressable. Recursive
                 data structures do not have these properties, so new
                 techniques must be developed. In this article, we
                 describe an execution model for supporting programs
                 that use pointer-based dynamic data structures. This
                 model uses a simple mechanism for migrating a thread of
                 control based on the layout of heap-allocated data and
                 introduces parallelism using a technique based on
                 futures and lazy task creation. We intend to exploit
                 this execution model using compiler analyses and
                 automatic parallelization techniques. We have
                 implemented a prototype system, which we call {\em
                 Olden}, that runs on the Intel iPSC/860 and the
                 Thinking Machines CM-5. We discuss our implementation
                 and report on experiments with five benchmarks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages; measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Run-time environments. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming, Parallel programming. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Dynamic storage management.",
}

@Article{Palsberg:1995:EIA,
  author =       "Jens Palsberg and Cun Xiao and Karl Lieberherr",
  title =        "Efficient Implementation of Adaptive Software",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "264--292",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201066.html",
  abstract =     "Adaptive programs compute with objects, just like
                 object-oriented programs. Each task to be accomplished
                 is specified by a so-called propagation pattern which
                 traverses the receiver object. The object traversal is
                 a recursive descent via the instance variables where
                 information is collected or propagated along the way. A
                 propagation pattern consists of (1) a name for the
                 task, (2) a succinct specification of the parts of the
                 receiver object that should be traversed, and (3) code
                 fragments to be executed when specific object types are
                 encountered. The propagation patterns need to be
                 complemented by a class graph which defines the
                 detailed object structure. The separation of structure
                 and behavior yields a degree of flexibility and
                 understandability not present in traditional
                 object-oriented languages. For example, the class graph
                 can be changed without changing the adaptive program at
                 all. We present an efficient implementation of adaptive
                 programs. Given an adaptive program and a class graph,
                 we generate an efficient object-oriented program, for
                 example, in C++. Moreover, we prove the correctness of
                 the core of this translation. A key assumption in the
                 theorem is that the traversal specifications are
                 consistent with the class graph. We prove the soundness
                 of a proof system for conservatively checking
                 consistency, and we show how to implement it
                 efficiently.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.2.m}: Software, SOFTWARE ENGINEERING,
                 Miscellaneous, Reusable software. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Object-oriented languages. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Webber:1995:OFP,
  author =       "Adam Webber",
  title =        "Optimization of Functional Programs by Grammar
                 Thinning",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "293--330",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201067.html",
  abstract =     "We describe a new technique for optimizing first-order
                 functional programs. Programs are represented as graph
                 grammars, and optimization proceeds by counterexample:
                 when a graph generated by the grammar is found to
                 contain an unnecessary computation, the optimizer
                 attempts to reformulates the grammar so that it never
                 again generates any graph that contains that
                 counterexample. This kind of program reformulation
                 corresponds to an interesting problem on context-free
                 grammars. Our reformulation technique is derived from
                 an (approximate) solution to this CFG problem. An
                 optimizer called Thinner is the proof of concept for
                 this technique. Thinner is a fully automatic,
                 source-to-source optimizer for a Lisp-like language of
                 purely functional, first-order programs. Thinner
                 rediscovers a wide variety of common compiler
                 optimizations. It also finds other more exotic
                 transformations, including the well-known Fibonacci
                 reformulation and the Knuth-Morris-Pratt
                 optimization.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative languages. {\bf F.4.2}: Theory of
                 Computation, MATHEMATICAL LOGIC AND FORMAL LANGUAGES,
                 Grammars and Other Rewriting Systems, Grammar types.",
}

@Article{Debray:1995:CDA,
  author =       "Saumya K. Debray",
  title =        "On the Complexity of Dataflow Analysis of Logic
                 Programs",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "331--365",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201068.html",
  abstract =     "It is widely held that there is a correlation between
                 complexity and precision in dataflow analysis, in the
                 sense that the more precise an analysis algorithm, the
                 more computationally expensive it must be. The details
                 of this relationship, however, appear to not have been
                 explored extensively. This article reports some results
                 on this correlation in the context of logic programs. A
                 formal notion of the ``precision'' of an analysis
                 algorithm is proposed, and this is used to characterize
                 the worst-case computational complexity of a number of
                 dataflow analyses with different degrees of precision.
                 While this article considers the analysis of logic
                 programs, the technique proposed, namely the use of
                 ``exactness sets'' to study relationships between
                 complexity and precision of analyses, is not specific
                 to logic programming in any way, and is equally
                 applicable to flow analyses of other language
                 families.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf F.2.2}: Theory of Computation, ANALYSIS OF
                 ALGORITHMS AND PROBLEM COMPLEXITY, Nonnumerical
                 Algorithms and Problems, Complexity of proof
                 procedures. {\bf D.1.6}: Software, PROGRAMMING
                 TECHNIQUES, Logic Programming. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Nonprocedural languages. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Walicki:1995:CCM,
  author =       "Michal Walicki and Sigurd Meidal",
  title =        "A Complete Calculus for the Multialgebraic and
                 Functional Semantics of Nondeterminism",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "366--393",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201070.html",
  abstract =     "The current algebraic models for nondeterminism focus
                 on the notion of {\em possibility\/} rather than {\em
                 necessity\/} and consequently equate (nondeterministic)
                 terms that one would intuitively not consider equal.
                 Furthermore, existing models for nondeterminism depart
                 radically from the standard models for (equational)
                 specifications of deterministic operators. One would
                 prefer that a specification language for
                 nondeterministic operators be based on an extension of
                 the standard model concepts, preferably in such a way
                 that the reasoning system for (possibly
                 nondeterministic) operators becomes the standard
                 equational one whenever restricted to the deterministic
                 operators---the objective should be to {\em minimize\/}
                 the departure from the standard frameworks. In this
                 article we define a specification language for
                 nondeterministic operators and multialgebraic
                 semantics. The first {\em complete\/} reasoning system
                 for such specifications is introduced. We also define a
                 transformation of specifications of nondeterministic
                 operators into derived specifications of deterministic
                 ones, obtaining a ``computational'' semantics of
                 nondeterministic specification by adopting the standard
                 semantics of the derived specification as the semantics
                 of the original one. This semantics turns out to be a
                 refinement of multialgebra semantics. The calculus is
                 shown to be sound and complete also with respect to the
                 new semantics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Alternation and
                 nondeterminism. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nonprocedural languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nondeterministic languages. {\bf
                 D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Specification techniques. {\bf F.3.2}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Semantics of Programming Languages, Algebraic
                 approaches to semantics. {\bf I.1.3}: Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Languages and
                 Systems, Nonprocedural languages. {\bf I.1.3}:
                 Computing Methodologies, ALGEBRAIC MANIPULATION,
                 Languages and Systems, Substitution mechanisms. {\bf
                 F.1.2}: Theory of Computation, COMPUTATION BY ABSTRACT
                 DEVICES, Modes of Computation, Relations among modes.
                 {\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Alternation and
                 nondeterminism.",
}

@Article{Carle:1995:MBI,
  author =       "Alan Carle and Lori Pollock",
  title =        "Matching-Based Incremental Evaluators for Hierarchical
                 Attribute Grammar Dialects",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "2",
  pages =        "394--429",
  month =        mar,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201071.html",
  abstract =     "Although attribute grammars have been very effective
                 for defining individual modules of language
                 translators, they have been rather ineffective for
                 specifying large program-transformational systems.
                 Recently, several new attribute grammar ``dialects''
                 have been developed that support the modular
                 specification of these systems by allowing modules,
                 each described by an attribute grammar, to be composed
                 to form a complete system. Acceptance of these new {\em
                 hierarchical\/} attribute grammar dialects requires the
                 availability of efficient batch and incremental
                 evaluators for hierarchical specifications. This paper
                 addresses the problem of developing efficient
                 incremental evaluators for hierarchical specifications.
                 A matching-based approach is taken in order to exploit
                 existing optimal change propagation algorithms for
                 nonhierarchical attribute grammars. A sequence of four
                 new matching algorithms is presented, each increasing
                 the number of previously computed attribute values that
                 are made available for reuse during the incremental
                 update.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding, Program editors. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Castagna:1995:CCC,
  author =       "Giuseppe Castagna",
  title =        "Covariance and Contravariance: Conflict without a
                 Cause",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "431--447",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203096.html",
  abstract =     "In type-theoretic research on object-oriented
                 programming, the issue of ``covariance versus
                 contravariance'' is a topic of continuing debate. In
                 this short note we argue that covariance and
                 contravariance appropriately characterize two distinct
                 and independent mechanisms. The so-called
                 contravariance rule correctly captures the {\em
                 subtyping\/} relation (that relation which establishes
                 which sets of functions can replace another given set
                 in {\em every context\/}). A covariant relation,
                 instead, characterizes the {\em specialization\/} of
                 code (i.e., the definition of new code which replaces
                 old definitions {\em in some particular cases\/}).
                 Therefore, covariance and contravariance are not
                 opposing views, but distinct concepts that each have
                 their place in object-oriented systems. Both can (and
                 should) be integrated in a type-safe manner in
                 object-oriented languages. We also show that the
                 independence of the two mechanisms is not
                 characteristic of a particular model but is valid in
                 general, since covariant specialization is present in
                 record-based models, although it is hidden by a
                 deficiency of all existing calculi that realize this
                 model. As an aside, we show that the $ \lambda
                 $-calculus can be taken as the basic calculus for both
                 an overloading-based and a record-based model. Using
                 this approach, one not only obtains a more uniform
                 vision of object-oriented type theories, but in the
                 case of the record-based approach, one also gains
                 multiple dispatching, a feature that existing
                 record-based models do not capture",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Object-oriented
                 languages.",
}

@Article{Carlisle:1995:TCC,
  author =       "W. H. Carlisle",
  title =        "Type Checking Concurrent {I/O}",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "448--460",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203097.html",
  abstract =     "In parallel programming languages multityped data
                 structures may be shared by two or more processes.
                 Process I/O to these structures is assumed to be
                 physically interleaved but logically parallel. This
                 article addresses a syntactic mechanism to specify a
                 type for such structures and extends an example
                 language and its type-checking algorithm to these
                 structures.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Data types
                 and structures. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Concurrent,
                 distributed, and parallel languages.",
}

@Article{Proebsting:1995:BAG,
  author =       "Todd A. Proebsting",
  title =        "{BURS} Automata Generation",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "461--486",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203098.html",
  abstract =     "A simple and efficient algorithm for generating
                 bottom-up rewrite system (BURS) tables is described. A
                 small code-generator generator implementation produces
                 BURS tables efficiently, even for complex instruction
                 set descriptions. The algorithm does not require novel
                 data structures or complicated algorithmic techniques.
                 Previously published methods for on-the-fly elimination
                 of states are generalized and simplified to create a
                 new method, triangle trimming, that is employed in the
                 algorithm. A prototype implementation, burg, generates
                 BURS tables very efficiently.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Code generation. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Cytron:1995:ECN,
  author =       "Ron K. Cytron and Jeanne Ferrante",
  title =        "Efficiently Computing $ \phi $-Nodes On-The-Fly",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "487--506",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 11:49:48 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203099.html",
  abstract =     "Recently, Static Single-Assignment Form and Sparse
                 Evaluation Graphs have been advanced for the efficient
                 solution of program optimization problems. Each method
                 is provided with an initial set of flow graph nodes
                 that inherently affect a problem's solution. Other
                 relevant nodes are those where potentially disparate
                 solutions must combine. Previously, these so-called $
                 \phi $-nodes were found by computing the iterated
                 dominance frontiers of the initial set of nodes, a
                 process that could take worst-case quadratic time with
                 respect to the input flow graph. In this article we
                 present an almost-linear algorithm for determining
                 exactly the same set of $ \phi $-nodes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Control structures. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 F.2.2}: Theory of Computation, ANALYSIS OF ALGORITHMS
                 AND PROBLEM COMPLEXITY, Nonnumerical Algorithms and
                 Problems, Computations on discrete structures. {\bf
                 G.2.2}: Mathematics of Computing, DISCRETE MATHEMATICS,
                 Graph Theory, Graph algorithms. {\bf I.1.2}: Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Algorithms,
                 Analysis of algorithms. {\bf I.2.2}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Program transformation.",
}

@Article{Abadi:1995:CS,
  author =       "Martin Abadi and Leslie Lamport",
  title =        "Conjoining Specifications",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "507--534",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/201069.html",
  abstract =     "We show how to specify components of concurrent
                 systems. The specification of a system is the
                 conjunction of its components' specifications.
                 Properties of the system are proved by reasoning about
                 its components. We consider both the decomposition of a
                 given system into parts, and the composition of given
                 parts to form a system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Specification techniques.
                 {\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs.",
}

@Article{Choy:1995:EFT,
  author =       "Manhoi Choy and Ambuj K. Singh",
  title =        "Efficient Fault-Tolerant Algorithms for Distributed
                 Resource Allocation",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "3",
  pages =        "535--559",
  month =        may,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203101.html",
  abstract =     "Solutions to resource allocation problems and other
                 related synchronization problems in distributed systems
                 are examined with respect to the measures of {\em
                 response time, message complexity, {\em and\/} failure
                 locality}. Response time measures the time it takes for
                 an algorithm to respond to the requests of a process;
                 message complexity measures the number of messages sent
                 and received by a process; and failure locality
                 characterizes the size of the network that is affected
                 by the failure of a single process. An algorithm for
                 the resource allocation problem that achieves a
                 constant failure locality of four along with a
                 quadratic response time and a quadratic message
                 complexity is presented. Applications of the algorithm
                 to other process synchronization problems in
                 distributed systems are also demonstrated.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.4.5}: Software, OPERATING SYSTEMS, Reliability,
                 Fault-tolerance. {\bf C.2.4}: Computer Systems
                 Organization, COMPUTER-COMMUNICATION NETWORKS,
                 Distributed Systems. {\bf D.1.3}: Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Concurrent programming structures. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Concurrency. {\bf D.4.1}: Software,
                 OPERATING SYSTEMS, Process Management, Mutual
                 exclusion. {\bf D.4.1}: Software, OPERATING SYSTEMS,
                 Process Management, Synchronization.",
}

@Article{Fricker:1995:ICI,
  author =       "Christine Fricker and Olivier Temam and William
                 Jalby",
  title =        "Influence of Cross-Interferences on Blocked Loops: a
                 Case Study with Matrix-Vector Multiply",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "4",
  pages =        "561--575",
  month =        jul,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/210185.html",
  abstract =     "State-of-the art data locality optimizing algorithms
                 are targeted for local memories rather than for cache
                 memories. Recent work on cache interferences seems to
                 indicate that these phenomena can severely affect
                 blocked algorithms cache performance. Because of cache
                 conflicts, it is not possible to know the precise gain
                 brought by blocking. It is even difficult to determine
                 for which problem sizes blocking is useful. Computing
                 the actual optimal block size is difficult because
                 cache conflicts are highly irregular. In this article,
                 we illustrate the issue of precisely evaluating
                 cross-interferences in blocked loops with blocked
                 matrix-vector multiply. Most significant interference
                 phenomena are captured because unusual parameters such
                 as array base addresses are being considered. The
                 techniques used allow us to compute the precise
                 improvement due to blocking and the threshold value of
                 problem parameters for which the blocked loop should be
                 preferred. It is also possible to derive an expression
                 of the optimal block size as a function of problem
                 parameters. Finally, it is shown that a precise rather
                 than an approximate evaluation of cache conflicts is
                 sometimes necessary to obtain near-optimal
                 performance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "measurement; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf C.4}: Computer Systems
                 Organization, PERFORMANCE OF SYSTEMS, Modeling
                 techniques. {\bf B.3.2}: Hardware, MEMORY STRUCTURES,
                 Design Styles, Cache memories.",
}

@Article{Palsberg:1995:TSE,
  author =       "Jens Palsberg and Patrick O'Keefe",
  title =        "A Type System Equivalent to Flow Analysis",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "4",
  pages =        "576--599",
  month =        jul,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/210187.html",
  abstract =     "Flow-based safety analysis of higher-order languages
                 has been studied by Shivers, and Palsberg and
                 Schwartzbach. Open until now is the problem of finding
                 a type system that accepts exactly the same programs as
                 safety analysis. In this article we prove that Amadio
                 and Cardelli's type system with subtyping and recursive
                 types accepts the same programs as a certain safety
                 analysis. The proof involves mappings from types to
                 flow information and back. As a result, we obtain an
                 inference algorithm for the type system, thereby
                 solving an open problem.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf F.4.3}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Formal
                 Languages, Operations on languages.",
}

@Article{Girkar:1995:ETL,
  author =       "Milind Girkar and Constantine D. Polychronopoulos",
  title =        "Extracting Task-Level Parallelism",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "4",
  pages =        "600--634",
  month =        jul,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/210189.html",
  abstract =     "Automatic detection of {\em task-level parallelism\/}
                 (also referred to as functional, DAG, unstructured, or
                 thread parallelism) at various levels of program
                 granularity is becoming increasingly important for
                 parallelizing and back-end compilers. Parallelizing
                 compilers detect iteration-level or coarser granularity
                 parallelism which is suitable for parallel computers;
                 detection of parallelism at the statement-or
                 operation-level is essential for most modern
                 microprocessors, including superscalar and VLIW
                 architectures. In this article we study the problem of
                 detecting, expressing, and optimizing task-level
                 parallelism, where ``task'' refers to a program
                 statement of arbitrary granularity. Optimizing the
                 amount of functional parallelism (by allowing
                 synchronization between arbitrary nodes) in sequential
                 programs requires the notion of {\em precedence\/} in
                 terms of paths in graphs which incorporate control and
                 data dependences. Precedences have been defined before
                 in a different context; however, the definition was
                 dependent on the ideas of parallel execution and time.
                 We show that the problem of determining precedences
                 statically is NP-complete. Determining precedence
                 relationships is useful in finding the essential data
                 dependences. We show that there exists a unique minimum
                 set of essential data dependences; finding this minimum
                 set is NP-hard and NP-easy. We also propose a heuristic
                 algorithm for finding the set of essential data
                 dependences. Static analysis of a program in the
                 Perfect Benchmarks was done, and we present some
                 experimental results.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 F.1.3}: Theory of Computation, COMPUTATION BY ABSTRACT
                 DEVICES, Complexity Classes, Reducibility and
                 completeness. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Code generation.",
}

@Article{VanHentenryck:1995:BTC,
  author =       "Pascal {Van Hentenryck} and Viswanath Ramachandran",
  title =        "Backtracking without Trailing in {CLP($ {\cal
                 R}_{\hbox {Lin}}$)}",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "4",
  pages =        "635--671",
  month =        jul,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:59:04 1998",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/210192.html",
  abstract =     "Existing CLP languages support backtracking by
                 generalizing traditional Prolog implementations:
                 modifications to the constraint system are trailed and
                 restored on backtracking. Although simple and
                 efficient, trailing may be very demanding in memory
                 space, since the constraint system may potentially be
                 saved at each choice point.\par

                 This article proposes a new implementation scheme for
                 backtracking in CLP languages over linear (rational or
                 real) arithmetic. The new scheme, called {\em semantic
                 backtracking}, does not use trailing but rather
                 exploits the semantics of the constraints to undo the
                 effect of newly added constraints. Semantic
                 backtracking reduces the space complexity compared to
                 implementations based on trailing by making it
                 essentially independent of the number of choice points.
                 In addition, semantic backtracking introduces
                 negligible space and time overhead on deterministic
                 programs. The price for this improvement is an increase
                 in backtracking time, although constraint-solving time
                 may actually decrease. The scheme has been implemented
                 as part of a complete CLP system CLP ($ R_{\mbox
                 {Lin}}$) and compared analytically and experimentally
                 with optimized trailing implementations. Experimental
                 results on small and real-life problems indicate that
                 semantic backtracking produces significant reduction in
                 memory space, while keeping the time overhead
                 reasonably small.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages; performance",
  subject =      "{\bf D.1.1}: Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nonprocedural languages. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.1.6}: Software,
                 PROGRAMMING TECHNIQUES, Logic Programming.",
}

@Article{McKenzie:1995:ERS,
  author =       "Bruce J. McKenzie and Corey Yeatman and Lorraine {De
                 Vere}",
  title =        "Error Repair in Shift-Reduce Parsers",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "4",
  pages =        "672--689",
  month =        jul,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 26 07:49:28 1999",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See failure report \cite{Bertsch:1999:FPT}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/210193.html",
  abstract =     "Local error repair of strings during CFG parsing
                 requires the insertion and deletion of symbols in the
                 region of a syntax error to produce a string that is
                 error free. Rather than precalculating tables at parser
                 generation time to assist in finding such repairs, this
                 article shows how such repairs can be found during
                 shift-reduce parsing by using the parsing tables
                 themselves. This results in a substantial space saving
                 over methods that require precalculated tables.
                 Furthermore, the article shows how the method can be
                 integrated with lookahead to avoid finding repairs that
                 immediately result in further syntax errors. The
                 article presents the results of experiments on a
                 version of the LALR(1)-based parser generator {\em
                 Bison\/} to which the algorithm was added.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Parsing. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Translator writing systems and
                 compiler generators. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.2.5}:
                 Software, SOFTWARE ENGINEERING, Testing and Debugging,
                 Error handling and recovery.",
}

@Article{Sloane:1995:EAG,
  author =       "Anthony M. Sloane",
  title =        "An Evaluation of an Automatically Generated Compiler",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "5",
  pages =        "691--703",
  month =        sep,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/213980.html",
  abstract =     "Compilers or language translators can be generated
                 using a variety of formal specification techniques.
                 Whether generation is worthwhile depends on the effort
                 required to specify the translation task and the
                 quality of the generated compiler. A systematic
                 comparison was conducted between a hand-coded
                 translator for the Icon programming language and one
                 generated by the Eli compiler construction system. A
                 direct comparison could be made since the generated
                 program performs the same translation as the hand-coded
                 program. The results of the comparison show that
                 efficient compilers can be generated from
                 specifications that are much smaller and more problem
                 oriented than the equivalent source code. We also found
                 that further work must be done to reduce the dynamic
                 memory usage of the generated compilers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages; performance",
  subject =      "{\bf C.4}: Computer Systems Organization, PERFORMANCE
                 OF SYSTEMS, Measurement techniques. {\bf D.2.m}:
                 Software, SOFTWARE ENGINEERING, Miscellaneous, Reusable
                 software. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators.",
}

@Article{Cejtin:1995:HOD,
  author =       "Henry Cejtin and Suresh Jagannathan and Richard
                 Kelsey",
  title =        "Higher-Order Distributed Objects",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "5",
  pages =        "704--739",
  month =        sep,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/213986.html",
  abstract =     "We describe a distributed implementation of Scheme
                 that permits efficient transmission of higher-order
                 objects such as closures and continuations. The
                 integration of distributed communication facilities
                 within a higher-order programming language engenders a
                 number of new abstractions and paradigms for
                 distributed computing. Among these are user-specified
                 load-balancing and migration policies for threads,
                 incrementally linked distributed computations, and
                 parameterized client-server applications. To our
                 knowledge, this is the first distributed dialect of
                 Scheme (or a related language) that addresses
                 lightweight communication abstractions for higher-order
                 objects.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages",
  subject =      "{\bf D.1.3}: Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Distributed programming. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Extensible languages. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Concurrent programming structures. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, SCHEME.",
}

@Article{Kurlander:1995:EIS,
  author =       "Steven M. Kurlander and Todd A. Proebsting and Charles
                 N. Fischer",
  title =        "Efficient Instruction Scheduling for Delayed-Load
                 Architectures",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "5",
  pages =        "740--776",
  month =        sep,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/213987.html",
  abstract =     "A fast, optimal code-scheduling algorithm for
                 processors with a delayed load of one instruction cycle
                 is described. The algorithm minimizes both execution
                 time and register use and runs in time proportional to
                 the size of the expression-tree. An extension that
                 spills registers when too few registers are available
                 is also presented. The algorithm also performs very
                 well for delayed loads of greater than one instruction
                 cycle. A heuristic that schedules DAGs and is based on
                 our optimal expression-tree-scheduling algorithm is
                 presented and compared with Goodman and Hsu's algorithm
                 Integrated Prepass Scheduling (IPS). Both schedulers
                 perform well on benchmarks with small basic blocks, but
                 on large basic blocks our scheduler outperforms IPS and
                 is significantly faster.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Masticola:1995:LFM,
  author =       "Stephen P. Masticola and Thomas J. Marlowe and Barbara
                 G. Ryder",
  title =        "Lattice Frameworks for Multisource and Bidirectional
                 Data Flow Problems",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "5",
  pages =        "777--803",
  month =        sep,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 5 07:58:42 MST 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/213989.html",
  abstract =     "{\em Multisource\/} data flow problems involve
                 information which may enter nodes independently through
                 different classes of edges. In some cases, dissimilar
                 meet operations appear to be used for different types
                 of nodes. These problems include {\em bidirectional\/}
                 and {\em flow-sensitive\/} problems as well as many
                 static analyses of concurrent programs with
                 synchronization. {\em K-tuple frameworks}, a type of
                 standard data flow framework, provide a natural
                 encoding for multisource problems using a single meet
                 operator. Previously, the solution of these problems
                 has been described as the fixed point of a set of data
                 flow equations. Using our $k$-tuple representation, we
                 can access the general results of standard data flow
                 frameworks concerning convergence time and solution
                 precision for these problems. We demonstrate this for
                 the bidirectional component of partial redundancy
                 suppression and two problems on the program summary
                 graph. An interesting subclass of $k$-tuple frameworks,
                 the {\em join-of-meets\/} frameworks, is useful for
                 reachability problems, especially those stemming from
                 analyses of explicitly parallel programs. We give
                 results on function space properties for join-of-meets
                 frameworks that indicate precise solutions for most of
                 them will be difficult to obtain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors.",
}

@Article{Chambers:1995:TMM,
  author =       "Craig Chambers and Gary T. Leavens",
  title =        "Typechecking and Modules for Multimethods",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "6",
  pages =        "805--843",
  month =        nov,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 02 09:05:25 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/218571.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; theory",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Modules, packages. {\bf
                 D.1.5}: Software, PROGRAMMING TECHNIQUES,
                 Object-oriented Programming. {\bf F.2.0}: Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, General. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Type structure.",
}

@Article{Ohori:1995:PRC,
  author =       "Atsushi Ohori",
  title =        "A Polymorphic Record Calculus and Its Compilation",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "6",
  pages =        "844--895",
  month =        nov,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 02 09:05:25 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/218572.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Lambda calculus and related systems.",
}

@Article{Sekar:1995:FSA,
  author =       "R. Sekar and I. V. Ramakrishnan",
  title =        "Fast Strictness Analysis Based on Demand Propagation",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "6",
  pages =        "896--937",
  month =        nov,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 02 09:05:25 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/218573.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.1}: Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory.
                 {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative languages.",
}

@Article{Anonymous:1995:AI,
  author =       "Anonymous",
  title =        "1995 Author Index",
  journal =      j-TOPLAS,
  volume =       "17",
  number =       "6",
  pages =        "938--940",
  month =        nov,
  year =         "1995",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 06 14:21:36 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-pb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Murer:1996:IAS,
  author =       "Stephan Murer and Stephen Omohundro and David
                 Stoutamire and Clemens Szyperski",
  title =        "Iteration abstraction in {Sather}",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "1",
  pages =        "1--15",
  month =        jan,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/225541.html",
  abstract =     "Sather extends the notion of an iterator in a powerful
                 new way. We argue that iteration abstractions belong in
                 class interfaces on an equal footing with routines.
                 Sather iterators were derived from CLU iterators but
                 are much more flexible and better suited for
                 object-oriented programming. We retain the property
                 that iterators are {\em structured}, i.e., strictly
                 bound to a controlling structured statement. We
                 motivate and describe the construct along with several
                 simple examples. We compare it with iteration based on
                 CLU iterators, cursors, riders, streams, series,
                 generators, coroutines, blocks, closures, and lambda
                 expressions. Finally, we describe experiences with
                 iterators in the Sather compiler and libraries.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf D.1.5}: Software, PROGRAMMING TECHNIQUES,
                 Object-oriented Programming. {\bf D.3.3}: Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features, Coroutines. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Control primitives. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Control structures.",
}

@Article{Carle:1996:OCP,
  author =       "Alan Carle and Lori Pollock",
  title =        "On the optimality of change propagation for
                 incremental evaluation of hierarchical attribute
                 grammars",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "1",
  pages =        "16--29",
  month =        jan,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/225542.html",
  abstract =     "Several new attribute grammar dialects have recently
                 been developed, all with the common goal of allowing
                 large, complex language translators to be specified
                 through a modular composition of smaller attribute
                 grammars. We refer to the class of dialects as {\em
                 hierarchical attribute grammars}. In this short
                 article, we present a characterization of optimal
                 incremental evaluation that indicates the unsuitability
                 of change propagation as the basis of an optimal
                 incremental evaluator for hierarchical attribute
                 grammars. This result lends strong support to the use
                 of incremental evaluators based on more applicative
                 approaches to attribute evaluation, such as Carle and
                 Pollock's evaluator based on more applicative
                 approaches to attribute evaluation, such as Carle and
                 Pollock's evaluator based on caching of partially
                 attributed subtree, Pugh's evaluator based on function
                 caching of semantic functions, and Swierstra and Vogt's
                 evaluator based on functions, and Swierstra and Vogt's
                 evaluator based on function caching of visit
                 sequences.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf D.2.3}: Software, SOFTWARE
                 ENGINEERING, Coding, Program editors. {\bf D.2.6}:
                 Software, SOFTWARE ENGINEERING, Programming
                 Environments. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Translator writing systems and
                 compiler generators. {\bf D.3.1}: Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Syntax. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics.",
}

@Article{VanderZanden:1996:IAS,
  author =       "Brad {Vander Zanden}",
  title =        "An incremental algorithm for satisfying hierarchies of
                 multiway dataflow constraints",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "1",
  pages =        "30--72",
  month =        jan,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See corrigendum \cite{VanderZanden:1996:CIA}.",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/225543.html",
  abstract =     "One-way dataflow constraints have gained popularity in
                 many types of interactive systems because of their
                 simplicity, efficiency, and manageability. Although it
                 is widely acknowledged that multiway dataflow
                 constraint could make it easier to specify certain
                 relationships in these applications, concerns about
                 their predictability and efficiency have impeded their
                 acceptance. Constraint hierarchies have been developed
                 to address the predictability problem, and incremental
                 algorithms have been developed to address the
                 efficiency problem. However, existing incremental
                 algorithms for satisfying constraint hierarchies
                 encounter two difficulties: (1) they are incapable of
                 guaranteeing an acyclic solution if a constraint
                 hierarchy has one or more cyclic solutions and (2) they
                 require worst-case exponential time to satisfy systems
                 of multioutput constraints. This article surmounts
                 these difficulties by presenting an incremental
                 algorithm called QuickPlan that satisfies in worst-case
                 $ O(N^2) $ time any hierarchy of multiway, multioutput
                 dataflow constraint that has at least one acyclic
                 solution, where $N$ is the number of constraints. With
                 benchmarks and real problems that can be solved
                 efficiently using existing algorithms, its performance
                 is competitive or superior. With benchmarks and real
                 problems that cannot be solved using existing
                 algorithms or that cannot be solved efficiently,
                 QuickPlan finds solutions and does so efficiently,
                 typically in $ O(N)$ time or less. QuickPlan is based
                 on the strategy of propagation of degrees of freedom.
                 The only restriction it imposes is that every
                 constraint method must use all of the variables in the
                 constraint as either an input or an output variable.
                 This requirement is met in every constraint-based,
                 interactive application that we have developed or
                 seen.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, User interfaces. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments. {\bf
                 I.1.3}: Computing Methodologies, ALGEBRAIC
                 MANIPULATION, Languages and Systems, Evaluation
                 strategies. {\bf I.1.2}: Computing Methodologies,
                 ALGEBRAIC MANIPULATION, Algorithms, Nonalgebraic
                 algorithms.",
}

@Article{Boyland:1996:CAG,
  author =       "John Tang Boyland",
  title =        "Conditional attribute grammars",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "1",
  pages =        "73--108",
  month =        jan,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/225544.html",
  abstract =     "Attribute grammars are a useful formalism for the
                 specification of computations on structured terms. The
                 classical definition of attribute grammars, however,
                 has no way of treating conditionals nonstrictly.
                 Consequently, the natural way of expressing many
                 otherwise well-behaved computations involves a
                 circularity. This article presents {\em conditional
                 attribute grammars}, and extension of attribute
                 grammars that enables more precise analysis of
                 conditionals. In conditional attribute grammars,
                 attribute equations may have guards. Equations are
                 active only when their guards are satisfied. The
                 standard attribute grammar evaluation classes are
                 definable for conditional attribute grammars, and the
                 corresponding evaluation techniques can be easily
                 adapted. However, determining membership in standard
                 evaluation classes such as 1-SWEEP, OAG, and SNC is
                 NP-hard.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators. {\bf F.4.2}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Grammars and
                 Other Rewriting Systems. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers.",
}

@Article{Hall:1996:TCH,
  author =       "Cordelia V. Hall and Kevin Hammond and Simon L.
                 {Peyton Jones} and Philip L. Wadler",
  title =        "Type classes in {Haskell}",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "2",
  pages =        "109--138",
  month =        mar,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/227700.html",
  abstract =     "This article defines a set of type inference rules for
                 resolving overloading introduced by type classes, as
                 used in the functional programming language Haskell.
                 Programs including type classes are transformed into
                 ones which may be typed by standard Hindley-Milner
                 inference rules. In contrast to other work on type
                 classes, the rules presented here relate directly to
                 Haskell programs. An innovative aspect of this work is
                 the use of second-order lambda calculus to record type
                 information in the transformed program.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Haskell. {\bf
                 D.1.1}: Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming.",
}

@Article{Hauser:1996:HFP,
  author =       "John R. Hauser",
  title =        "Handling floating-point exceptions in numeric
                 programs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "2",
  pages =        "139--174",
  month =        mar,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/227701.html",
  abstract =     "There are a number of schemes for handling arithmetic
                 exceptions that can be used to improve the speed (or
                 alternatively the reliability) of numeric code.
                 Overflow and underflow are the most troublesome
                 exceptions, and depending on the context in which the
                 exception can occur, they may be addressed either: (1)
                 through a ``brute force'' reevaluation with extended
                 range, (2) by reevaluating using a technique known as
                 {\em scaling}, (3) by substituting an infinity or zero,
                 or (4) in the case of underflow, with gradual
                 underflow. In the first two of these cases, the
                 offending computation is simply reevaluated using a
                 safer but slower method. The latter two cases are
                 cheaper, more automated schemes that ideally are built
                 in as options within the computer system. Other
                 arithmetic exceptions can be handled with similar
                 methods. These and some other techniques are examined
                 with an eye toward determining the support programming
                 languages and computer systems ought to provide for
                 floating-point exception handling. It is argued that
                 the cheapest short-term solution would be to give full
                 support to most of the {\em required\/} (as opposed to
                 recommended) special features of the IEC/IEEE Standard
                 for Binary Floating-Point Arithmetic. An essential part
                 of this support would include standardized access from
                 high-level languages to the exception flags defined by
                 the standard. Some possibilities outside the IEEE
                 Standard are also considered, and a few thought on
                 possible better-structured support within programming
                 languages are discussed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; performance;
                 standardization",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.0}: Software, PROGRAMMING LANGUAGES, General,
                 Standards. {\bf G.1.0}: Mathematics of Computing,
                 NUMERICAL ANALYSIS, General, Computer arithmetic. {\bf
                 G.1.0}: Mathematics of Computing, NUMERICAL ANALYSIS,
                 General, Numerical algorithms.",
}

@Article{Sands:1996:TCL,
  author =       "David Sands",
  title =        "Total correctness by local improvement in the
                 transformation of functional programs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "2",
  pages =        "175--234",
  month =        mar,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/227716.html",
  abstract =     "The goal of program transformation is to improve
                 efficiency while preserving meaning. One of the
                 best-known transformation techniques is Burstall and
                 Darlington's unfold-fold method. Unfortunately the
                 unfold-fold method itself guarantees neither
                 improvement in efficiency nor total correctness. The
                 correctness problem for unfold-fold is an instance of a
                 strictly more general problem: transformation by
                 locally equivalence-preserving steps does not
                 necessarily preserve (global) equivalence. This article
                 presents a condition for the total correctness of
                 transformations on recursive programs, which, for the
                 first time, deals with higher-order functional
                 languages (both strict and nonstrict) including lazy
                 data structures. The main technical result is an {\em
                 improvement theorem\/} which says that if the local
                 transformation steps are guided by certain optimization
                 concerns (a fairly natural condition for a
                 transformation), then correctness of the transformation
                 follows. The improvement theorem makes essential use of
                 a formalized improvement theory; as a rather pleasing
                 corollary it also guarantees that the transformed
                 program is a formal improvement over the original. The
                 theorem has immediate practical consequences: it is a
                 powerful tool for proving the correctness of existing
                 transformation methods for higher-order functional
                 programs, without having to ignore crucial factors such
                 as {\em memoization\/} or {\em folding}, and it yields
                 a simple syntactic method for guiding and constraining
                 the unfold-fold method in the general case so that
                 total correctness (and improvement) is always
                 guaranteed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; verification",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Correctness proofs. {\bf D.1.1}:
                 Software, PROGRAMMING TECHNIQUES, Applicative
                 (Functional) Programming. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Liao:1996:SAD,
  author =       "Stan Liao and Srinivas Devadas and Kurt Keutzer and
                 Steven Tjiang and Albert Wang",
  title =        "Storage assignment to decrease code size",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "235--253",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/229543.html",
  abstract =     "DSP architectures typically provide indirect
                 addressing modes with autoincrement and decrement. In
                 addition, indexing mode is generally not available, and
                 there are usually few, if any, general-purpose
                 registers. Hence, it is necessary to use address
                 registers and perform address arithmetic to access
                 automatic variables. Subsuming the address arithmetic
                 into autoincrement and decrement modes improves the
                 size of the generated code. In this article we present
                 a formulation of the problem of optimal storage
                 assignment such that explicit instructions for address
                 arithmetic are minimized. We prove that for the case of
                 a single address register the decision problem is
                 NP-complete, even for a single basic block. We then
                 generalize the problem to multiple address registers.
                 For both cases heuristic algorithms are given, and
                 experimental results are presented.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; management; measurement;
                 theory",
  subject =      "{\bf B.5.2}: Hardware, REGISTER-TRANSFER-LEVEL
                 IMPLEMENTATION, Design Aids, Optimization. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors. {\bf
                 G.2.2}: Mathematics of Computing, DISCRETE MATHEMATICS,
                 Graph Theory. {\bf F.4.1}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Proof theory.",
}

@Article{Smith:1996:PTV,
  author =       "Geoffrey Smith and Dennis Volpano",
  title =        "Polymorphic typing of variables and references",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "254--267",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/229544.html",
  abstract =     "In this article we consider the polymorphic type
                 checking of an imperative language. Our language
                 contains {\em variables}, first-class {\em
                 references\/} (pointers), and first-class functions.
                 Variables, as in traditional imperative languages, are
                 implicitly dereferenced, and their addresses
                 ($L$-values) are not first-class values. Variables are
                 easier to type check than references and, in many
                 cases, lead to more general polymorphic types. We
                 present a polymorphic type system for our language and
                 prove that it is sound. Programs that use variables
                 sometimes require weak types, as in Tofte's type system
                 for Standard ML, but such weak types arise far less
                 frequently with variables than with references",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques. {\bf D.3.0}:
                 Software, PROGRAMMING LANGUAGES, General.",
}

@Article{Knoop:1996:PFE,
  author =       "Jens Knoop and Bernhard Steffen and J{\"u}rgen
                 Vollmer",
  title =        "Parallelism for free: efficient and optimal bitvector
                 analyses for parallel programs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "268--299",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/229545.html",
  abstract =     "We consider parallel programs with shared memory and
                 interleaving semantics, for which we show how to
                 construct for unidirectional bitvector problems optimal
                 analysis algorithms that are as efficient as their
                 purley sequential counterparts and that can easily be
                 implemented. Whereas the complexity result is rather
                 obvious, our optimality result is a consequence of a
                 new Kam/Ullman-style Coincidence Theorem. Thus using
                 our method, the standard algorithms for sequential
                 programs computing liveness, availability, very
                 busyness, reaching definitions, definition-use chains,
                 or the analyses for performing code motion, assignment
                 motion, partial dead-code elimination or strength
                 reduction, can straightforward be transferred to the
                 parallel setting at almost no cost.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; performance; theory",
  subject =      "{\bf F.1.2}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Modes of Computation, Parallelism and
                 concurrency. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Concurrent,
                 distributed, and parallel languages. {\bf D.2.2}:
                 Software, SOFTWARE ENGINEERING, Tools and Techniques.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs. {\bf D.4.1}: Software, OPERATING
                 SYSTEMS, Process Management, Synchronization.",
}

@Article{George:1996:IRC,
  author =       "Lal George and Andrew W. Appel",
  title =        "Iterated register coalescing",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "300--324",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/229546.html",
  abstract =     "An important function of any register allocator is to
                 target registers so as to eliminate copy instructions.
                 Graph-coloring register allocation is an elegant
                 approach to this problem. If the source and destination
                 of a move instruction do not interfere, then their
                 nodes can be coalesced in the interference graph.
                 Chaitin's coalescing heuristic could make a graph
                 uncolorable (i.e., introduce spills); Briggs et al.
                 demonstrated a conservative coalescing heuristic that
                 preserves colorability. But Briggs's algorithm is {\em
                 too\/} conservative and leaves too many move
                 instructions in our programs. We show how to interleave
                 coloring reductions with Briggs's coalescing heuristic,
                 leading to an algorithm that is safe but much more
                 aggressive.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; measurement;
                 performance",
  subject =      "{\bf B.5.2}: Hardware, REGISTER-TRANSFER-LEVEL
                 IMPLEMENTATION, Design Aids, Optimization. {\bf I.2.8}:
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Problem Solving, Control Methods, and Search, Heuristic
                 methods. {\bf G.2.2}: Mathematics of Computing,
                 DISCRETE MATHEMATICS, Graph Theory, Graph algorithms.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization.",
}

@Article{Morgan:1996:PPT,
  author =       "Carroll Morgan and Annabelle McIver and Karen Seidel",
  title =        "Probabilistic predicate transformers",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "325--353",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 13 11:46:35 MDT 1996",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/229547.html",
  abstract =     "Probabilistic predicates generalize standard
                 predicates over a state space; with probabilistic
                 predicate transformers one thus reasons about
                 imperative programs in terms of probabilistic pre- and
                 postconditions. Probabilistic healthiness conditions
                 generalize the standard ones, characterizing ``real''
                 probabilistic programs, and are based on a connection
                 with an underlying relational model for probabilistic
                 execution; in both contexts demonic nondeterminism
                 coexists with probabilistic choice. With the
                 healthiness conditions, the associated
                 weakest-precondition calculus seems suitable for
                 exploring the rigorous derivation of small
                 probabilistic programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs. {\bf G.3}: Mathematics of
                 Computing, PROBABILITY AND STATISTICS. {\bf G.1.0}:
                 Mathematics of Computing, NUMERICAL ANALYSIS, General,
                 Condition (and ill-condition). {\bf F.1.2}: Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Modes of
                 Computation, Probabilistic computation. {\bf D.2.4}:
                 Software, SOFTWARE ENGINEERING, Program Verification.",
}

@Article{VanderZanden:1996:CIA,
  author =       "Brad {Vander Zanden}",
  title =        "Corrigendum: ``{An incremental algorithm for
                 satisfying hierarchies of multiway dataflow
                 constraints}''",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "3",
  pages =        "354--354",
  month =        may,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 31 15:57:33 1996",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{VanderZanden:1996:IAS}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Holzle:1996:RRP,
  author =       "Urs H{\"o}lzle and David Ungar",
  title =        "Reconciling Responsiveness with Performance in Pure
                 Object-Oriented Languages",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "4",
  pages =        "355--400",
  month =        jul,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/233562.html",
  abstract =     "Dynamically dispatched calls often limit the
                 performance of object-oriented programs, since
                 object-oriented programming encourages factoring code
                 into small, reusable units, thereby increasing the
                 frequency of these expensive operations. Frequent calls
                 not only slow down execution with the dispatch overhead
                 per se, but more importantly they hinder optimization
                 by limiting the range and effectiveness of standard
                 global optimizations. In particular, dynamically
                 dispatched calls prevent standard interprocedual
                 optimizations that depend on the availability of a
                 static call graph. The SELF implementation described
                 here offers tow novel approaches to optimization. {\em
                 Type feedback\/} speculatively inlines dynamically
                 dispatched calls based on profile information that
                 predicts likely receiver classes. {\em Adaptive
                 optimization\/} reconciles optimizing compilation with
                 interactive performance by incrementally optimizing
                 only the frequently executed parts of a program. When
                 combined, these two techniques result in a system that
                 can execute programs significantly faster than previous
                 systems while retaining much of the interactiveness of
                 an interpreted system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.1.5}: Software, PROGRAMMING TECHNIQUES,
                 Object-oriented Programming. {\bf D.2.6}: Software,
                 SOFTWARE ENGINEERING, Programming Environments,
                 Interactive. {\bf D.2.6}: Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.2.m}:
                 Software, SOFTWARE ENGINEERING, Miscellaneous, Rapid
                 prototyping. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Interpreters. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Run-time environments. {\bf
                 D.4.7}: Software, OPERATING SYSTEMS, Organization and
                 Design, Interactive systems.",
}

@Article{Abadi:1996:SM,
  author =       "Mart{\'\i}n Abadi and Luca Cardelli",
  title =        "On Subtyping and Matching",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "4",
  pages =        "401--423",
  month =        jul,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/233563.html",
  abstract =     "A relation between recursive object types, called {\em
                 matching}, has been proposed as a generalization of
                 subtyping. Unlike subtyping, matching does not support
                 subsumption, but it does support inheritance of binary
                 methods. We argue that matching is a good idea, but
                 that it should not be regarded as a form of F-bounded
                 subtyping (as was originally intended). We show that a
                 new interpretation of matching as higher-order
                 subtyping has better properties. Matching turns out to
                 be a third-order construction, possibly the only one to
                 have been proposed for general use in programming.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf D.1.5}: Software,
                 PROGRAMMING TECHNIQUES, Object-oriented Programming.",
}

@Article{McKinley:1996:IDL,
  author =       "Kathryn S. McKinley and Steve Carr and Chau-Wen
                 Tseng",
  title =        "Improving Data Locality with Loop Transformations",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "4",
  pages =        "424--453",
  month =        jul,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/233564.html",
  abstract =     "In the past decade, processor speed has become
                 significantly faster than memory speed. Small, fast
                 cache memories are designed to overcome this
                 discrepancy, but they are only effective when programs
                 exhibit {\em data locality}. In the this article, we
                 present compiler optimizations to improve data locality
                 based on a simple yet accurate cost model. The model
                 computes both {\em temporal\/} and {\em spatial\/}
                 reuse of cache lines to find desirable loop
                 organizations. The cost model drives the application of
                 compound transformations consisting of loop
                 permutation, loop fusion, loop distribution, and loop
                 reversal. To validate our optimization strategy, we
                 implemented our algorithms and ran experiments on a
                 large collection of scientific programs and kernels.
                 Experiments illustrate that for kernels our model and
                 algorithm can select and achieve the best loop
                 structure for a nest. For over 30 complete
                 applications, we executed the original and transformed
                 versions and simulated cache hit rates. We collected
                 statistics about the inherent characteristics of these
                 programs and our ability to improve their data
                 locality. To our knowledge, these studies are the first
                 of such breadth and depth. We found performance
                 improvements were difficult to achieve because
                 benchmark programs typically have high hit rates even
                 for small data caches; however, our optimizations
                 significantly improved several programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers.",
}

@Article{Foster:1996:CPP,
  author =       "Ian Foster",
  title =        "Compositional Parallel Programming Languages",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "4",
  pages =        "454--476",
  month =        jul,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/233565.html",
  abstract =     "In task-parallel programs, diverse activities can take
                 place concurrently, and communication and
                 synchronization patterns are complex and not easily
                 predictable. Previous work has identified {\em
                 compositionality\/} as an important design principle
                 for task-parallel programs. In this article, we discuss
                 alternative approaches to the realization of this
                 principle, which holds that properties of program
                 components should be preserved when those components
                 are composed in parallel with other program components.
                 We review two programming languages, Strand and Program
                 Composition Notation, that support compositionality via
                 a small number of simple concepts, namely, monotone
                 operations on shared objects, a uniform addressing
                 mechanism, and parallel composition. Both languages
                 have been used extensively for large-scale application
                 development, allowing us to provide an informed
                 assessment of both their strengths and their
                 weaknesses. We observe that while compositionality
                 simplifies development of complex applications, the use
                 of specialized languages hinders reuse of existing code
                 and tools and the specification of domain decomposition
                 strategies. This suggests an alternative approach based
                 on small extensions to existing sequential languages.
                 We conclude the article with a discussion of two
                 languages that realized this strategy.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Concurrent
                 programming structures.",
}

@Article{Haghighat:1996:SAP,
  author =       "Mohammad R. Haghighat and Constantine D.
                 Polychronopoulos",
  title =        "Symbolic Analysis for Parallelizing Compilers",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "4",
  pages =        "477--518",
  month =        jul,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/233568.html",
  abstract =     "The notion of dependence captures that most important
                 properties of a program for efficient execution on
                 parallel computers. The dependence structure of a
                 program defines that necessary constraints of the order
                 of execution of the program components and provides
                 sufficient information for the exploitation of the
                 available parallelism. Static discovery and management
                 of the dependence structure of programs save a
                 tremendous amount of execution time, and dynamic
                 utilization of dependence information results in a
                 significant performance gain on parallel computers.
                 However, experiments with parallel computers indicate
                 that existing multiprocessing environments are unable
                 to deliver the desired performance over a wide range of
                 real applications, mainly due to lack of precision of
                 their dependence information. This calls for an
                 effective compilation scheme capable of understanding
                 the dependence structure of complicated application
                 programs. This article describes a methodology for
                 capturing analyzing program properties that are
                 essential in the effective detection and efficient
                 exploitation of parallelism on parallel computers.
                 Based on this methodology, a symbolic analysis
                 framework is developed for the Parafrase-2
                 parallelizing compiler. This framework extends the
                 scope of a variety of important program analysis
                 problems and solves them in a unified way. The attained
                 solution space of these problems is much larger than
                 that handled by existing compiler technology. Such a
                 powerful approach is required for the effective
                 compilation of a large class of application
                 programs.\par

                 programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; languages; performance",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 D.4.1}: Software, OPERATING SYSTEMS, Process
                 Management, Scheduling. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs.
                 {\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf G.2.1}: Mathematics of Computing,
                 DISCRETE MATHEMATICS, Combinatorics, Recurrences and
                 difference equations. {\bf I.1.4}: Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Applications.
                 {\bf I.2.2}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Automatic analysis
                 of algorithms.",
}

@Article{Palsberg:1996:CTT,
  author =       "Jens Palsberg and Scott Smith",
  title =        "Constrained types and their expressiveness",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "5",
  pages =        "519--527",
  month =        sep,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/232715.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/232715.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/235454.html",
  abstract =     "A constrained type consists of both a standard type
                 and a constraint set. Such types enable efficient type
                 inference for object-oriented languages with
                 polymorphism and subtyping, as demonstrated by Eifrig,
                 Smith, and Trifonov. Until now, it has been unclear how
                 expressive constrained types are. In this article we
                 study constrained types without universal
                 quantification. We prove that they accept the same
                 programs as the type system of Amadio and Cardelli with
                 subtyping and recursive types. This result gives a
                 precise connection between constrained types and the
                 standard notion of types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.3}: Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features. {\bf
                 D.3.2}: Software, PROGRAMMING LANGUAGES, Language
                 Classifications.",
}

@Article{Dawson:1996:PPU,
  author =       "Steven Dawson and C. R. Ramakrishnan and Steven Skiena
                 and Terrance Swift",
  title =        "Principles and practice of unification factoring",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "5",
  pages =        "528--563",
  month =        sep,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/232722.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/232722.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/235455.html",
  abstract =     "The efficiency of resolution-based logic programming
                 languages, such as Prolog, depends critically on
                 selecting and executing sets of applicable clause heads
                 to resolve against subgoals. Traditional approaches to
                 this problem have focused on using indexing to
                 determine the smallest possible applicable set. Despite
                 their usefulness, these approaches ignore the
                 nondeterminism inherent in many programming languages
                 to the extent that they do not attempt to optimize
                 execution {\em after\/} the applicable set has been
                 determined. Unification factoring seeks to rectify this
                 omission by regarding the indexing and unification
                 phases of clause resolution as a single process. This
                 article formalizes that process through the
                 construction of {\em factoring automata}. A
                 polynomial-time algorithm is given for constructing
                 optimal factoring automata that preserve the clause
                 selection strategy of Prolog. More generally, when the
                 clause selection strategy is not fixed, constructing
                 such an optimal automaton is shown to be NP-complete,
                 solving an open trie minimization problem. Unification
                 factoring is implemented through a source code
                 transformation that preserves the full semantics of
                 Prolog. This transformation is specified in the
                 article, and using it, several well-known programs show
                 significant performance improvements across several
                 different systems. A prototype of unification factoring
                 is available by anonymous ftp.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; measurement; theory;
                 verification",
  subject =      "{\bf F.1.1}: Theory of Computation, COMPUTATION BY
                 ABSTRACT DEVICES, Models of Computation, Automata. {\bf
                 D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf F.2.2}: Theory of Computation,
                 ANALYSIS OF ALGORITHMS AND PROBLEM COMPLEXITY,
                 Nonnumerical Algorithms and Problems. {\bf F.1.3}:
                 Theory of Computation, COMPUTATION BY ABSTRACT DEVICES,
                 Complexity Classes. {\bf I.2.2}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Program transformation. {\bf D.3.4}:
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf F.1.1}: Theory
                 of Computation, COMPUTATION BY ABSTRACT DEVICES, Models
                 of Computation, Automata. {\bf F.2.2}: Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems,
                 Pattern matching.",
}

@Article{delaBanda:1996:GAC,
  author =       "M. Garcia {de la Banda} and M. Hermenegildo and M.
                 Bruynooghe and V. Dumortier and G. Janssens and W.
                 Simoens",
  title =        "Global analysis of constraint logic programs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "5",
  pages =        "564--614",
  month =        sep,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/232734.html",
  abstract =     "This article presents and illustrates a practical
                 approach to the dataflow analysis of constraint logic
                 programming languages using abstract interpretation. It
                 is first argued that, from the framework point of view,
                 it suffices to propose relatively simple extensions of
                 traditional analysis methods which have already been
                 proved useful and practical and for which efficient
                 fixpoint algorithms exist. This is shown by proposing a
                 simple extension of Bruynooghe's traditional framework
                 which allows it to analyze constraint logic programs.
                 Then, and using this generalized framework, two
                 abstract domains and their required abstract functions
                 are presented: the first abstract domain approximates
                 definiteness information and the second one freeness.
                 Finally, an approach for combining those domains is
                 proposed. The two domains and their combination have
                 been implemented and used in the analysis of CLP($R$)
                 and Prolog-III applications. Results form this
                 implementation showing its performance and accuracy are
                 also presented.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.1.m}: Software, PROGRAMMING
                 TECHNIQUES, Miscellaneous. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Nonprocedural languages. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{GarciaDeLaBanda:1996:GAC,
  author =       "M. {Garcia De La Banda} and M. Hermenegildo and M.
                 Bruynooghe and V. Dumortier and G. Janssens and W.
                 Simoens",
  title =        "Global analysis of constraint logic programs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "5",
  pages =        "564--614",
  month =        sep,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235456.html",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages; measurement",
  subject =      "{\bf D.1.6}: Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.2.2}: Software, SOFTWARE
                 ENGINEERING, Tools and Techniques. {\bf F.3.1}: Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Piquer:1996:IDG,
  author =       "Jos{\'e} M. Piquer",
  title =        "Indirect distributed garbage collection: Handling
                 object migration",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "5",
  pages =        "615--647",
  month =        sep,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/0164-0925/232711.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/232711.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/235457.html",
  abstract =     "In new distributed systems, object mobility is usually
                 allowed and is sometimes used by the underlying object
                 manager system to benefit from object access locality.
                 On the other hand, in-transit references to objects can
                 exist at any moment in asynchronous distributed
                 systems. In the presence of object mobility and
                 in-transit references, many garbage collector (GC)
                 algorithms fail to operate correctly. Others need to
                 use the system's object finder to find the objects
                 while performing their work. As a general principle, a
                 GC should never interfere with object manager polices
                 (such as forcing migration or fixing an object to a
                 given processor). However, if the GC uses the object
                 finder, it will change the access pattern of the
                 system, and eventually it could foul the global
                 allocation policy. In this article we propose a new GC
                 family, Indirect Garbage Collectors, allowing to
                 separate the problems of object management (placement,
                 replication, and retrieval) from garbage collection.
                 This property allows our algorithms to be implemented
                 on top of almost any existent distributed object
                 system, without having to use the object finder.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; management; performance;
                 verification",
  subject =      "{\bf C.2.4}: Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems,
                 Network operating systems. {\bf D.1.3}: Software,
                 PROGRAMMING TECHNIQUES, Concurrent Programming. {\bf
                 D.4.2}: Software, OPERATING SYSTEMS, Storage
                 Management, Distributed memories. {\bf D.4.2}:
                 Software, OPERATING SYSTEMS, Storage Management,
                 Allocation/deallocation strategies.",
}

@Article{Sreedhar:1996:ILU,
  author =       "Vugranam C. Sreedhar and Guang R. Gao and Yong-Fong
                 Lee",
  title =        "Identifying loops using {DJ} graphs",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "649--658",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235827.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236115.html",
  abstract =     "Loop identification is a necessary step in loop
                 transformations for high-performance architectures. One
                 classical technique for detecting loops is Tarjan's
                 interval-finding algorithm. The intervals identified by
                 Tarjan's method are single-entry, strongly connected
                 subgraphs that closely reflect a program's loop
                 structure. We present a simple algorithm for
                 identifying both reducible and irreducible loops using
                 DJ graphs. Our method is a generalization of Tarjan's
                 method, as it identifies nested intervals (or loops)
                 even in the presence of irreducibility.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 E.1}: Data, DATA STRUCTURES, Graphs. {\bf E.1}: Data,
                 DATA STRUCTURES, Trees.",
}

@Article{Skeppstedt:1996:UDA,
  author =       "Jonas Skeppstedt and Per Stenstr{\"o}m",
  title =        "Using dataflow analysis techniques to reduce ownership
                 overhead in cache coherence protocols",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "659--682",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235828.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236116.html",
  abstract =     "In this article, we explore the potential of classical
                 dataflow analysis techniques in removing overhead in
                 write-invalidate cache coherence protocols for
                 shared-memory multiprocessors. We construct three
                 compiler algorithms with varying degree of
                 sophistication that detect loads followed by stores to
                 the same address. Such loads are marked and constitute
                 a hint to the cache to obtain an exclusive copy of the
                 block so that the subsequent store does not introduce
                 access penalties. The simplest of the three compiler
                 algorithms analyzes the existence of load-store
                 sequences within each basic blocks of code whereas the
                 other two analyze load-store sequences across basic
                 blocks at the intraprocedural level. The algorithms
                 have been incorporated into an optimizing C compiler,
                 and we have evaluated their efficiencies by compiling
                 and executing seven parallel programs on a simulated
                 multiprocessor. Our results show that the detection
                 efficiency of the most aggressive algorithm is 96\% or
                 higher for four of the seven programs studied. We also
                 compare the efficiency of these static algorithms with
                 that of dynamic hardware-based algorithms that reduce
                 ownership overhead. We find that the static analysis
                 using classical dataflow analysis results in similar
                 performance improvements as dynamic hardware-based
                 approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf B.3.2}: Hardware, MEMORY
                 STRUCTURES, Design Styles, Cache memories. {\bf C.1.2}:
                 Computer Systems Organization, PROCESSOR ARCHITECTURES,
                 Multiple Data Stream Architectures (Multiprocessors),
                 Multiple-instruction-stream, multiple-data-stream
                 processors (MIMD). {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers.",
}

@Article{Proebsting:1996:DDR,
  author =       "Todd A. Proebsting and Charles N. Fischer",
  title =        "Demand-driven register allocation",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "683--710",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235829.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236117.html",
  abstract =     "A new global register allocation technique, {\em
                 demand-driven register allocation}, is described.
                 Demand-driven register allocation quantifies the costs
                 and benefits of allocating variables to registers over
                 live ranges so that high-quality allocations can be
                 made. Local allocation is done first, and then global
                 allocation is done iteratively beginning in the most
                 deeply nested loops. Because local allocation precedes
                 global allocation, demand-driven allocation does not
                 interfere with the use of well-known, high-quality
                 local register allocation and instruction-scheduling
                 techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.",
}

@Article{Attali:1996:NSE,
  author =       "Isabelle Attali and Denis Caromel and Sidi Ould
                 Ehmety",
  title =        "A natural semantics for {Eiffel} dynamic binding",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "711--729",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235830.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236118.html",
  abstract =     "This article formally defines Eiffel dynamic binding
                 in presence of renaming and redefinition. Message
                 passing, inheritance, and polymorphism are expressed in
                 an operational style using natural semantics. From the
                 formal specification, we derive an algorithm to
                 determine the appropriate version of a feature to apply
                 to a given object. This algorithm, based only on the
                 class hierarchy and not using any intermediate
                 structure, gives a practical approach to the
                 understanding of inheritance, renaming, and
                 redefinition in Eiffel.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Operational semantics. {\bf D.1.5}:
                 Software, PROGRAMMING TECHNIQUES, Object-oriented
                 Programming. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications, Languages.
                 {\bf D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.2}:
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Eiffel.",
}

@Article{Danvy:1996:EED,
  author =       "Olivier Danvy and Karoline Malmkj{\ae}r and Jens
                 Palsberg",
  title =        "Eta-expansion does the trick",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "730--751",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 9 11:33:28 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235831.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236119.html",
  abstract =     "Partial-evaluation folklore has it that massaging
                 one's source programs can make them specialize better.
                 In Jones, Gomard, and Sestoft's recent textbook, a
                 whole chapter is dedicated to listing such
                 ``binding-time improvements'': nonstandard use of
                 continuation-passing style, eta-expansion, and a
                 popular transformation called ``The Trick.'' We provide
                 a unified view of these binding-time improvements, from
                 a typing perspective. Just as a proper treatment of
                 product values in partial evaluation requires partially
                 static values, a proper treatment of disjoint sums
                 requires moving static contexts across dynamic case
                 expressions. This requirement precisely accounts for
                 the nonstandard use of continuation-passing style
                 encountered in partial evaluation. Eta-expansion thus
                 acts as a uniform binding-time coercion between values
                 and contexts, be they of function type, product type,
                 or disjoint-sum type. For the latter case, it enables
                 ``The Trick.'' In this article, we extend Gomard and
                 Jones' partial evaluator for the [lambda]-calculus,
                 [lambda]-Mix, with products and disjoint sums; we point
                 out how eta-expansion for (finite) disjoint sums enable
                 The Trick; we generalize our earlier work by
                 identifying the eta-expansion can be obtained in the
                 binding-time analysis simple by adding two coercion
                 rules; and we specify and prove the correctness of our
                 extension to [lambda]-Mix.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Procedures, functions, and
                 subroutines. {\bf D.1.1}: Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Translator writing systems and compiler generators.
                 {\bf F.3.2}: Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages,
                 Operational semantics. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Functional constructs. {\bf
                 F.4.1}: Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Mathematical Logic, Lambda calculus
                 and related systems. {\bf I.1.3}: Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Languages and
                 Systems, Evaluation strategies. {\bf I.2.2}: Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Automatic analysis of algorithms.",
}

@Article{Zhou:1996:PPC,
  author =       "Neng-Fa Zhou",
  title =        "Parameter passing and control stack management in
                 {Prolog} implementation revisited",
  journal =      j-TOPLAS,
  volume =       "18",
  number =       "6",
  pages =        "752--779",
  month =        nov,
  year =         "1996",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:57:57 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/toc/Abstracts/toplas/235832.html;
                 http://www.acm.org/pubs/toc/Abstracts/toplas/236120.html",
  abstract =     "Parameter passing and control stack management are two
                 of the crucial issues in Prolog implementation. In the
                 Warren Abstract Machine (WAM), the most widely used
                 abstract machine for Prolog implementation, arguments
                 are passed through argument registers, and the
                 information associated with procedure calls is stored
                 in possibly two frames. Although accessing registers is
                 faster than accessing memory, this scheme requires the
                 argument registers to be saved and restored for back
                 tracking and makes it difficult to implement full tail
                 recursion elimination. These disadvantages may far
                 outweigh the advantage in emulator-based
                 implementations because registers are actually
                 simulated by using memory. In this article, we
                 reconsider the two crucial issues and describe a new
                 abstract machine called ATOAM (yet Another
                 Tree-Oriented Abstract Machine). The ATOAM differs from
                 the WAM mainly in that (1) arguments are passed
                 directly into stack frames, (2) only one frame is used
                 for each procedure call, and (3) procedures are
                 translated into matching trees is possible, and clauses
                 in each procedure are indexed on all input arguments.
                 The above-mentioned inefficiencies of the WAM do not
                 exist in the ATOAM because backtracking requires less
                 bookkeeping operations, and tail recursion can be
                 handled in most cases like a loop statement in
                 procedural languages. An ATOAM-emulator-based Prolog
                 system called B-Prolog has been implemented, which is
                 available through anonymous ftp from {\tt
                 ftp.kyutech.ac.jp (131.206.1.101)} in the directory
                 {\tt pub/Language/prolog}. B-Prolog is comparable in
                 performance with and can sometimes be significantly
                 faster than emulated SICStus-Prolog. By measuring the
                 numbers of memory and register references made in both
                 systems, we found that passing arguments in stack is no
                 worse than passing arguments in registers even if
                 accessing memory is four times as expensive as
                 accessing registers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; languages",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.1.6}: Software,
                 PROGRAMMING TECHNIQUES, Logic Programming. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features.",
}

@Article{Horwitz:1997:PFI,
  author =       "Susan Horwitz",
  title =        "Precise Flow-Insensitive May-Alias Analysis is
                 {NP-Hard}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "1--6",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p1-horwitz/",
  abstract =     "Determining aliases is one of the fundamental static
                 analysis problems, in part because the precision with
                 which this problem is solved can affect the precision
                 of other analyses such as live variables, available
                 expressions, and constant propagation. Previous work
                 has investigated the complexity of flow-sensitive alias
                 analysis. In this article we show that precise
                 flow-{\em insensitive\/} may-alias analysis is NP-hard
                 given arbitrary levels of pointers and arbitrary
                 pointer dereferencing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 F.4.1}: Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Mathematical Logic, Computability
                 theory. {\bf F.4.3}: Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Formal
                 Languages, Decision problems.",
}

@Article{Cortesi:1997:CAI,
  author =       "Agostino Cortesi and Gilberto File and Roberto
                 Giacobazzi and Catuscia Palamidessi and Francesco
                 Ranzato",
  title =        "Complementation in Abstract Interpretation",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "7--47",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p7-cortesi/",
  abstract =     "Reduced product of abstract domains is a rather
                 well-known operation for domain composition in abstract
                 interpretation. In this article, we study its inverse
                 operation, introducing a notion of domain
                 complementation in abstract interpretation.
                 Complementation provides as systematic way to design
                 new abstract domains, and it allows to systematically
                 decompose domains. Also, such an operation allows to
                 simplify domain verification problems, and it yields
                 space-saving representations for complex domains. We
                 show that the complement exists in most cases, and we
                 apply complementation to three well-know abstract
                 domains, notably to Cousot and Cousot's interval domain
                 for integer variable analysis, to Cousot and Cousot's
                 domain for comportment analysis of functional
                 languages, and to the domain {\em Sharing\/} for
                 aliasing analysis of logic languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 D.3.1}: Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics.",
}

@Article{Steckler:1997:LCC,
  author =       "Paul A. Steckler and Mitchell Wand",
  title =        "Lightweight Closure Conversion",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "48--86",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p48-steckler/",
  abstract =     "We consider the problem of lightweight closure
                 conversion, in which multiple procedure call protocols
                 may coexist in the same code. A lightweight closure
                 omits bindings for some of the free variables of the
                 procedure that is represents. Flow analysis is used to
                 match the protocol expected by each procedure and the
                 protocol used at its possible call sites. We formulate
                 the flow analysis as a deductive system that generates
                 a labeled transition system and a set of constraints.
                 We show that any solution to the constraints justifies
                 the resulting transformation. Some of the techniques
                 used are similar to those of abstract interpretation,
                 but others appear to be novel.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf F.3.2}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Operational semantics. {\bf D.3.3}:
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features, Procedures, functions, and subroutines.
                 {\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Assertions. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions.",
}

@Article{Wright:1997:PST,
  author =       "Andrew K. Wright and Robert Cartwright",
  title =        "A Practical Soft Type System for {Scheme}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "87--152",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p87-wright/",
  abstract =     "A {\em soft type system\/} infers types for the
                 procedures and data structures of dynamically typed
                 programs. Like conventional static types, soft types
                 express program invariants and thereby provide valuable
                 information for program optimization and debugging. A
                 soft type {\em checker\/} uses the types inferred by a
                 soft type system to eliminate run-time checks that are
                 provably unnecessary; any remaining run-time checks are
                 flagged as potential program errors. {\em Soft
                 Scheme\/} is a practical soft type checker for R4RS
                 Scheme. Its underlying type system generalizes
                 conventional Hindley-Milner type inference by
                 incorporating recursive types and a limited form of
                 union type. Soft Scheme accommodates all of R4RS Scheme
                 including uncurried procedures of fixed and variable
                 arity, assignment, and continuations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "performance; reliability",
  subject =      "{\bf F.3.3}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Studies of Program Constructs,
                 Type structure. {\bf D.3.2}: Software, PROGRAMMING
                 LANGUAGES, Language Classifications, Applicative
                 languages. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Optimization.",
}

@Article{Baumgartner:1997:ISC,
  author =       "Gerald Baumgartner and Vincent F. Russo",
  title =        "Implementing Signatures for {C++}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "153--187",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p153-baumgartner/",
  abstract =     "We outline the design and detail the implementation of
                 a language extension for abstracting types and for
                 decoupling subtyping and inheritance in C++. This
                 extension gives the user more of the flexibility of
                 dynamic typing while retaining the efficiency and
                 security of static typing. After a brief discussion of
                 syntax and semantics of this language extension and
                 examples of its use, we present and analyze three
                 different implementation techniques: a preprocessor to
                 a C++ compiler, an implementation in the front end of a
                 C++ compiler, and a low-level implementation with
                 back-end support. We follow with an analysis of the
                 performance of the three implementation techniques and
                 show that our extension actually allows subtype
                 polymorphism to be implemented more efficiently than
                 with virtual functions. We conclude with a discussion
                 of the lessons we learned for future programming
                 language design.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; measurement; performance",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Abstract data types. {\bf
                 D.2.2}: Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Modules and interfaces. {\bf D.1.5}:
                 Software, PROGRAMMING TECHNIQUES, Object-oriented
                 Programming. {\bf D.3.4}: Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers.",
}

@Article{Calder:1997:EBS,
  author =       "Brad Calder and Dirk Grunwald and Michael Jones and
                 Donald Lindsay and James Martin and Michael Mozer and
                 Benjamin Zorn",
  title =        "Evidence-Based Static Branch Prediction Using Machine
                 Learning",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "1",
  pages =        "188--222",
  month =        jan,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 12 08:06:48 MST 1997",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-1/p188-calder/",
  abstract =     "Correctly predicting the direction that branches will
                 take is increasingly important in today's wide-issue
                 computer architectures. The name {\em program-based\/}
                 branch prediction is given to static branch prediction
                 techniques that base their prediction on a program's
                 structure. In this article, we investigate a new
                 approach to program-based branch prediction that uses a
                 body of existing programs to predict the branch
                 behavior in a new program. We call this approach to
                 program-based branch prediction {\em evidence-based
                 static prediction}, or ESP. The main idea of ESP is
                 that the behavior of a corpus of programs can be used
                 to infer the behavior of new programs. In this article,
                 we use neural networks and decision trees to map static
                 features associated with each branch to a prediction
                 that the branch will be taken. ESP shows significant
                 advantages over other prediction mechanisms.
                 Specifically, it is a program-based technique; it is
                 effective across a range of programming languages and
                 programming styles; and it does not rely on the use of
                 expert-defined heuristics. In this article, we describe
                 the application of ESP to the problem of static branch
                 prediction and compare our results to existing
                 program-based branch predictors. We also investigate
                 the applicability of ESP across computer architectures,
                 programming languages, compilers, and run-time systems.
                 We provide results showing how sensitive ESP is to the
                 number and type of static features and programs
                 included in the ESP training sets, and we compare the
                 efficacy of static branch prediction for subroutine
                 libraries. Averaging over a body of 43 C and Fortran
                 programs, ESP branch prediction results in a miss rate
                 of 20\%, as compared with the 25\% miss rate obtained
                 using the best existing program-based heuristics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; measurement; performance",
  subject =      "{\bf I.2.6}: Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Learning, Parameter learning. {\bf C.4}:
                 Computer Systems Organization, PERFORMANCE OF SYSTEMS,
                 Measurement techniques. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf I.2.6}: Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Learning, Connectionism and
                 neural nets.",
}

@Article{Pippenger:1997:PVI,
  author =       "Nicholas Pippenger",
  title =        "Pure versus impure {Lisp}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "223--238",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p223-pippenger/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "language constructs and features. {\bf f.3.3}: theory
                 of computation; logics and meanings of programs;
                 program and recursion schemes.; programming languages;
                 studies of program constructs; {\bf d.3.3}: software",
  subject =      "{\bf D.3.3}: Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.3}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Program and recursion schemes.",
}

@Article{Sreedhar:1997:ICD,
  author =       "Vugranam C. Sreedhar and Guang R. Gao and Yong-Fong
                 Lee",
  title =        "Incremental computation of dominator trees",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "239--252",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p239-sreedhar/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compilers. {\bf d.3.4}: software; data structures;
                 graphs. {\bf e.1}: data; optimization. {\bf e.1}: data;
                 processors; programming languages; trees.; {\bf d.3.4}:
                 software",
  subject =      "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 E.1}: Data, DATA STRUCTURES, Graphs. {\bf E.1}: Data,
                 DATA STRUCTURES, Trees.",
}

@Article{Dams:1997:AIR,
  author =       "Dennis Dams and Rob Gerth and Orna Grumberg",
  title =        "Abstract interpretation of reactive systems",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "253--291",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p253-dams/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "logics and meanings of programs; logics of programs.;
                 mechanical verification. {\bf f.3.1}: theory of
                 computation; program verification; software
                 engineering; specifying and verifying and reasoning
                 about programs; validation. {\bf f.3.1}: theory of
                 computation; {\bf d.2.4}: software",
  subject =      "{\bf D.2.4}: Software, SOFTWARE ENGINEERING, Program
                 Verification, Validation. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Mechanical verification. {\bf F.3.1}: Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Logics of programs.",
}

@Article{Yellin:1997:PSC,
  author =       "Daniel M. Yellin and Robert E. Strom",
  title =        "Protocol specifications and component adaptors",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "292--333",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p292-yellin/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency.; concurrent programming. {\bf d.2.1}:
                 software; general; operating systems; process
                 management; programming techniques;
                 requirements/specifications. {\bf d.4.1}: software;
                 software engineering; systems specification
                 methodology. {\bf d.1.3}: software; {\bf c.0}: computer
                 systems organization",
  subject =      "{\bf C.0}: Computer Systems Organization, GENERAL,
                 Systems specification methodology. {\bf D.1.3}:
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming. {\bf D.2.1}: Software, SOFTWARE
                 ENGINEERING, Requirements/Specifications. {\bf D.4.1}:
                 Software, OPERATING SYSTEMS, Process Management,
                 Concurrency.",
}

@Article{Sansom:1997:FBP,
  author =       "Patrick M. Sansom and Simon L. {Peyton Jones}",
  title =        "Formally based profiling for higher-order functional
                 languages",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "334--385",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p334-sansom/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "applicative languages. {\bf d.3.4}: software;
                 compilers. {\bf d.3.4}: software; debugging aids. {\bf
                 d.3.2}: software; language classifications; logics and
                 meanings of programs; operational semantics.;
                 optimization. {\bf f.3.2}: theory of computation;
                 processors; programming languages; semantics of
                 programming languages; software engineering; testing
                 and debugging; {\bf d.2.5}: software",
  subject =      "{\bf D.2.5}: Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.3.2}: Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative languages. {\bf D.3.4}: Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4}: Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf F.3.2}: Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Semantics of
                 Programming Languages, Operational semantics.",
}

@Article{Yang:1997:SMC,
  author =       "Jin Yang and Aloysius K. Mok and Farn Wang",
  title =        "Symbolic model checking for event-driven real-time
                 systems",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "2",
  pages =        "386--412",
  month =        mar,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed May 14 09:00:40 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-2/p386-yang/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "computational logic.; logics and meanings of programs;
                 mathematical logic; mathematical logic and formal
                 languages; mechanical verification. {\bf f.3.1}: theory
                 of computation; specification techniques. {\bf f.4.1}:
                 theory of computation; specifying and verifying and
                 reasoning about programs; {\bf f.3.1}: theory of
                 computation",
  subject =      "{\bf F.3.1}: Theory of Computation, LOGICS AND
                 MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 F.3.1}: Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Specification techniques. {\bf F.4.1}: Theory
                 of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic, Computational logic.",
}

@Article{Clarke:1997:URE,
  author =       "Charles L. A. Clarke and Gordon V. Cormack",
  title =        "On the use of Regular Expressions for Searching Text",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "413--426",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p413-clarke/",
  abstract =     "The use of regular expressions for text search is
                 widely known and well understood. It is then surprising
                 that the standard techniques and tools prove to be of
                 limited use for searching structured text formatted
                 with SGML or similar markup languages. Our experience
                 with structured text search has caused us to reexamine
                 the current practice. The generally accepted rule of
                 ``leftmost longest match'' is an unfortunate choice and
                 is at the root of the difficulties. We instead propose
                 a rule which is semantically cleaner. This rule is
                 generally applicable to a variety of text search
                 applications, including source code analysis, and has
                 interesting properties in its own right. We have
                 written a publicly available search tool implementing
                 the theory in the article, which has proved valuable in
                 a variety of circumstances.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms",
  subject =      "{\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Specialized application languages",
}

@Article{Kozen:1997:KAT,
  author =       "Dexter Kozen",
  title =        "{Kleene} Algebra with Tests",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "427--443",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p427-kozen/",
  abstract =     "We introduce Kleene algebra with tests, an equational
                 system for manipulating programs. We give a purely
                 equational proof, using Kleene algebra with tests and
                 commutativity conditions, of the following classical
                 result: every {\bf while} program can be simulated by a
                 while program can be simulated by a {\bf while} program
                 with at most one {\bf while} loop. The proof
                 illustrates the use of Kleene algebra with tests and
                 commutativity conditions in program equivalence
                 proofs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf D.2.2} Software, SOFTWARE ENGINEERING, Tools and
                 Techniques, Structured programming. {\bf D.2.4}
                 Software, SOFTWARE ENGINEERING, Program Verification,
                 Correctness proofs. {\bf D.3.3} Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features, Control
                 structures. {\bf F.3.1} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Assertions. {\bf F.3.1}
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Invariants. {\bf F.3.1} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 F.3.1} Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Specifying and Verifying and Reasoning about
                 Programs, Mechanical verification. {\bf F.3.1} Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Pre- and post-conditions. {\bf F.3.1} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Specification techniques. {\bf F.3.2} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Algebraic approaches to
                 semantics. {\bf F.3.3} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs, Control primitives. {\bf I.1.1} Computing
                 Methodologies, ALGEBRAIC MANIPULATION, Expressions and
                 Their Representation, Simplification of expressions.
                 {\bf I.1.3} Computing Methodologies, ALGEBRAIC
                 MANIPULATION, Languages and Systems, Special-purpose
                 algebraic systems. {\bf I.2.2} Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 modification. {\bf I.2.2} Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 synthesis; program transformation; program
                 verification",
}

@Article{Hu:1997:FDE,
  author =       "Zhenjiang Hu and Hideya Iwasaki and Masato Takechi",
  title =        "Formal Derivation of Efficient Parallel Programs by
                 Construction of List Homomorphisms",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "444--461",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p444-hu/",
  abstract =     "It has been attracting much attention to make use of
                 list homomorphisms in parallel programming because they
                 ideally suit the divide-and-conquer parallel paradigm.
                 However, they have been usually treated rather
                 informally and ad hoc in the development of efficient
                 parallel programs. What is worse is that some
                 interesting functions, e.g., the maximum segment sum
                 problem, are basically not list homomorphisms. In this
                 article, we propose a systematic and formal way for the
                 construction of a list homomorphism for a given problem
                 so that an efficient parallel program is derived. We
                 show, with several well-known but nontrivial problems,
                 how a straightforward, and ``obviously'' correct, but
                 quite inefficient solution to the problem can be
                 successfully turned into a semantically equivalent
                 ``almost list homomorphism.'' The derivation is based
                 on two transformations, namely tupling and fusion,
                 which are defined according to the specific recursive
                 structures of list homomorphisms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.1.1} Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.1.3}
                 Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming, Parallel programming. {\bf F.3.3} Theory
                 of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Studies of Program Constructs, Program and recursion
                 schemes. {\bf I.2.2} Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Automatic Programming, Program
                 transformation and derivation",
}

@Article{Pingali:1997:OCD,
  author =       "Keshav Pingali and Gianfranco Bilardi",
  title =        "Optimal Control Dependence Computation and the {Roman}
                 Chariots Problem",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "462--491",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p462-pingali/",
  abstract =     "The control dependence relation plays a fundamental
                 role in program restructuring and optimization. The
                 usual representation of this relation is the control
                 dependence graph (CDG), but the size of the CDG can
                 grow quadratically with the input programs, even for
                 structured programs. In this article, we introduce the
                 augmented postdominator tree {\em (APT)}, a data
                 structure which can be constructed in space and time
                 proportional to the size of the program and which
                 supports enumeration of a number of useful control
                 dependence sets in time proportional to their size.
                 Therefore, {\em APT\/} provides an optimal
                 representation of control dependence. Specifically, the
                 {\em APT\/} data structure supports enumeration of the
                 set cd(e), which is the set of statements control
                 dependent on control-flow edge e, of the set {\bf
                 conds}(w), which is the set of edges on which statement
                 $w$ is dependent, and of the set {\bf cdequiv}($w$),
                 which is the set of statements having the same control
                 dependences as $w$. Technically, {\em APT\/} can be
                 viewed as a factored representation of the CDG where
                 queries are processed using an approach known as
                 filtering search.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 I.1.2} Computing Methodologies, ALGEBRAIC MANIPULATION,
                 Algorithms, Analysis of algorithms",
}

@Article{Ramsey:1997:SRM,
  author =       "Norman Ramsey and Mary F. Fern{\'a}ndez",
  title =        "Specifying Representations of Machine Instructions",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "492--524",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "This article was written using the {\tt noweb}
                 literate programming system.",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p492-ramsey/",
  abstract =     "We present SLED, a specification language for Encoding
                 and Decoding, which describes, abstract, binary, and
                 assembly-language representations of machine
                 instructions. Guided by a SLED specification, the New
                 Jersey Machine-Code Toolkit generates bit-manipulating
                 code for use in applications that process machine code.
                 Programmers can write such applications at an assembly
                 language level of abstraction, and the toolkit enables
                 the applications to recognize and emit the binary
                 representations used by the hardware. SLED is suitable
                 for describing both CISC and RISC machines; we have
                 specified representations of MIPS R3000, SPARC, Alpha,
                 and Intel Pentium instructions, and toolkit users have
                 written specifications for the Power PC and Motorola
                 68000. The article includes representative excerpts
                 from our SPARC and Pentium specifications. SLED uses
                 four elements; {\em fields\/} and {\em tokens\/}
                 describe parts of instructions; {\em patterns\/}
                 describe binary representations of instructions or
                 group of instructions; and {\em constructors\/} map
                 between the abstract and binary levels. By combining
                 the elements in different ways, SLED supports
                 machine-independent implementations of machine-level
                 concepts like conditional assembly, span-dependent
                 instructions, relocatable addresses, object code,
                 sections, and relocation. SLED specifications can be
                 checked automatically for consistency with existing
                 assemblers. The implementation of the toolkit is
                 largely determined by our representations of patterns
                 and constructors. We use a normal form that facilitates
                 construction of encoders and decoders. The article
                 describes the normal form and its use. The toolkit has
                 been used to help build several applications. We have
                 built a retargetable debugger and a retargetable,
                 optimizing linker. Colleagues have built a dynamic code
                 generator, a decompiler, and an execution-time
                 analyzer. The toolkit generates efficient code; for
                 example, the linker emits binary up to 15\% faster than
                 it emits assembly language, making it 1.7-2 times
                 faster to produce an a.out directly than by using the
                 assembler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf C.0} Computer Systems Organization, GENERAL,
                 Systems specification methodology. {\bf D.3.2}
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Specialized application languages.
                 {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Translator writing systems and compiler
                 generators",
}

@Article{Gerber:1997:SRT,
  author =       "Richard Gerber and Seongsoo Hong",
  title =        "Slicing real-time programs for enhanced
                 schedulability",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "3",
  pages =        "525--555",
  month =        may,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 11 18:32:35 MDT 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1997-19-3/p525-gerber/",
  abstract =     "In this article we present a compiler-based technique
                 to help develop correct real-time systems. The domain
                 we consider is that of multiprogrammed real-time
                 applications, in which periodic tasks control physical
                 systems via interacting with external sensors and
                 actuators. While a system is up and running, these
                 operations must be performed as specified---otherwise
                 the system may fail. Correctness depends not only on
                 each program individually, but also on the
                 time-multiplexed behavior of all of the programs
                 running together. Errors due to overloaded resources
                 are exposed very late in a development process, and
                 often at runtime. They are usually remedied by
                 human-intensive activities such as instrumentation,
                 measurement, code tuning and redesign. We describe a
                 static alternative to this process, which relies on
                 well-accepted technologies from optimizing compilers
                 and fixed-priority scheduling. Specifically, when a set
                 of tasks are found to be overloaded, a scheduling
                 analyzer determines candidate tasks to be transformed
                 via program slicing. The slicing engine decomposes each
                 of the selected tasks into two fragments: one that is
                 ``time critical'' and the other ``unobservable.'' The
                 unobservable part is then spliced to the end of the
                 time-critical code, with the external semantics being
                 maintained. The benefit is that the scheduler may
                 postpone the unobservable code beyond its original
                 deadline, which can enhance overall schedulability.
                 While the optimization is completely local, the
                 improvement is realized globally, for the entire task
                 set.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages",
  subject =      "{\bf C.3} Computer Systems Organization,
                 SPECIAL-PURPOSE AND APPLICATION-BASED SYSTEMS,
                 Real-time systems. {\bf D.3.4} Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 J.7} Computer Applications, COMPUTERS IN OTHER SYSTEMS,
                 Real time",
}

@Article{Havlak:1997:NRI,
  author =       "Paul Havlak",
  title =        "Nesting of Reducible and Irreducible Loops",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "4",
  pages =        "557--567",
  month =        jul,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-4/p557-havlak/",
  abstract =     "Recognizing and transforming loops are essential steps
                 in any attempt to improve the running time of a
                 program. Aggressive restructuring techniques have been
                 developed for single-entry (reducible) loops, but
                 restructurers and the dataflow and dependence analysis
                 they rely on often give up in the presence of
                 multientry (irreducible) loops. Thus one irreducible
                 loop can prevent the improvement of all loops in a
                 procedure. This article give an algorithm to build a
                 loop nesting tree for a procedure with arbitrary
                 control flow. The algorithm uses definitions of
                 reducible and irreducible loops which allow either kind
                 of loop to be nested in the other. The tree
                 construction algorithm, an extension of Tarjan's
                 algorithm for testing reducibility, runs in almost
                 linear time. In the presence of irreducible loops, the
                 loop nesting tree can depend on the depth-first
                 spanning tree used to build it. In particular, the
                 header node representing a reducible loop in one
                 version of the loop nesting tree can be the
                 representative of an irreducible loop in another. We
                 give a normalization method that maximizes the set of
                 reducible loops discovered, independent of the
                 depth-first spanning tree used. The normalization
                 require the insertion of at most one node and one edge
                 per reducible loop.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages",
  subject =      "{\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 F.3.3} Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Studies of Program Constructs. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Debray:1997:ICF,
  author =       "Saumya K. Debray and Todd A. Proebsting",
  title =        "Interprocedural Control Flow Analysis of First-Order
                 Programs with Tail-Call Optimization",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "4",
  pages =        "568--585",
  month =        jul,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-4/p568-debray/",
  abstract =     "Knowledge of low-level control flow is essential for
                 many compiler optimizations. In systems with tail-call
                 optimization, the determination of interprocedural
                 control flow is complicated by the fact that because of
                 tail-call optimization, control flow at procedure
                 returns is not readily evident from the call graph of
                 the program. This article shows how interprocedural
                 control-flow analysis of first-order programs can be
                 carried out using well-known concepts from parsing
                 theory. In particular, we show that context-insensitive
                 (or zeroth-order) control-flow analysis corresponds to
                 the notion of FOLLOW sets in context-free grammars,
                 while context-sensitive (or first-order) control-flow
                 analysis corresponds to the notion of LR(1) items. The
                 control-flow information so obtained can be used to
                 improve the precision of interprocedural dataflow
                 analyses as well as to extend certain low-level code
                 optimizations across procedure boundaries.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; languages; management",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.3} Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features.",
}

@Article{Breuer:1997:RCS,
  author =       "Peter T. Breuer and Carlos Delgado Kloos and
                 Andr{\'e}s Mar{\'i}n L{\'o}pez and Natividad
                 Mart{\'i}nez Madrid and Luis S{\'a}nchez
                 Fern{\'a}ndez",
  title =        "A Refinement Calculus for the Synthesis of Verified
                 Hardware Descriptions in {VHDL}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "4",
  pages =        "586--616",
  month =        jul,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-4/p586-breuer/",
  abstract =     "A formal refinement calculus targeted at system-level
                 descriptions in the IEEE standard hardware description
                 language VHDL is described here. Refinement can be used
                 to develop hardware description code that is ``correct
                 by construction''. the calculus is closely related to a
                 Hoare-style programming logic for VHDL and real-time
                 systems in general. That logic and a semantics for a
                 core subset of VHDL are described. The programming
                 logic and the associated refinement calculus are shown
                 to be {\em complete.\/} This means that if there is a
                 code that can be shown to implement a given
                 specification, then it will be derivable from the
                 specification via the calculus.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf B.6.3} Hardware, LOGIC DESIGN, Design Aids,
                 Hardware description languages. {\bf D.1.6} Software,
                 PROGRAMMING TECHNIQUES, Logic Programming. {\bf B.1.4}
                 Hardware, CONTROL STRUCTURES AND MICROPROGRAMMING,
                 Microprogram Design Aids, Languages and compilers.",
}

@Article{Emerson:1997:USW,
  author =       "E. A. Emerson and A. P. Sistla",
  title =        "Utilizing Symmetry when Model-Checking under Fairness
                 Assumptions: An Automata-Theoretic Approach",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "4",
  pages =        "617--638",
  month =        jul,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-4/p617-emerson/",
  abstract =     "One useful technique for combating the state explosion
                 problem is to exploit symmetry when performing temporal
                 logic model checking. In previous work it is shown how,
                 using some basic notions of group theory, symmetry may
                 be exploited for the full range of correctness
                 properties expressible in the very expressive temporal
                 logic CTL*. Surprisingly, while fairness properties are
                 readily expressible in CTL*, these methods are not
                 powerful enough to admit any amelioration of state
                 explosion, when fairness assumptions are involved. We
                 show that it is nonetheless possible to handle fairness
                 efficiently by trading some group theory for automata
                 theory. Our automata-theoretic approach depends on
                 detecting fair paths subtly encoded in a quotient
                 structure whose arcs are annotated with permutations,
                 by using a threaded structure that reflects coordinate
                 shifts caused by the permutations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; theory; verification",
  subject =      "{\bf F.3.1} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs. {\bf F.1.1} Theory of Computation,
                 COMPUTATION BY ABSTRACT DEVICES, Models of Computation.
                 {\bf D.2.4} Software, SOFTWARE ENGINEERING,
                 Software/Program Verification.",
}

@Article{Bergstra:1997:TCT,
  author =       "J. A. Bergstra and T. B. Dinesh and J. Field and J.
                 Heering",
  title =        "Toward a Complete Transformational Toolkit for
                 Compilers",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "5",
  pages =        "639--684",
  month =        sep,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-5/p639-bergstra/",
  abstract =     "PIM is an equational logic designed to function as a
                 ``transformational toolkit'' for compilers and other
                 programming tools that analyze and manipulate
                 imperative languages. It has been applied to such
                 problems as program slicing, symbolic evaluation,
                 conditional constant propagation, and dependence
                 analysis. PIM consists of the untyped lambda calculus
                 extended with an algebraic data type that characterizes
                 the behavior of lazy stores and generalized
                 conditionals. A graph form of PIM terms is by design
                 closely related to several intermediate representations
                 commonly used in optimizing compilers. In this article,
                 we show that PIM's core algebraic component. PIMt,
                 possesses a {\em complete\/} equational axiomatization
                 (under the assumption of certain reasonable
                 restrictions on term formation). This has the practical
                 consequence of guaranteeing that every
                 semantics-preserving transformation on a program
                 representable in PIMt can be derived by application of
                 PIMt rules. We systematically derive the complete PIMt
                 logic as the culmination of a sequence of increasingly
                 powerful equational systems starting from a
                 straightforward ``interpreter'' for closed PIMt terms.
                 This work is an intermediate step in a larger program
                 to develop a set of well-founded tools for manipulation
                 of imperative programs by compilers and other systems
                 that perform program analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf F.3.2} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Algebraic approaches to
                 semantics.",
}

@Article{DeBoer:1997:PCC,
  author =       "Frank S. {De Boer} and Maurizio Gabbrielli and Elena
                 Marchiori and Catuscia Palamidessi",
  title =        "Proving Concurrent Constraint Programs Correct",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "5",
  pages =        "685--725",
  month =        sep,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-5/p685-de_boer/",
  abstract =     "We introduce a simple compositional proof system for
                 proving (partial) correctness of concurrent constraint
                 programs (CCP). The proof system is based on a
                 denotational approximation of the strongest
                 postcondition semantics of CCP programs. The proof
                 system is proved to be correct for full CCP and
                 complete for the class of programs in which the
                 denotational semantics characterizes exactly the
                 strongest postcondition. This class includes the
                 so-called confluent CCP, a special case of which is
                 constraint logic programming with dynamic scheduling.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.1.3} Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.3.1} Software,
                 PROGRAMMING LANGUAGES, Formal Definitions and Theory,
                 Semantics. {\bf F.3.1} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Logics of programs. {\bf
                 F.3.2} Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Denotational semantics.",
}

@Article{Clarke:1997:VPN,
  author =       "E. M. Clarke and O. Grumberg and S. Jha",
  title =        "Verifying Parameterized Networks",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "5",
  pages =        "726--750",
  month =        sep,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-5/p726-clarke/",
  abstract =     "This article describes a technique based on network
                 grammars and abstraction t verify families of
                 state-transition systems. The family of
                 state-transition systems is represented by a
                 context-free network grammar. Using the structure of
                 the network grammar our technique constructs a process
                 invariant that {\em simulates\/} all the
                 state-transition systems in the family. A novel idea
                 introduced in this article is the use of {\em regular
                 languages\/} to express state properties. We have
                 implemented our techniques and verified two nontrivial
                 examples.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf B.6.2} Hardware, LOGIC DESIGN, Reliability and
                 Testing**. {\bf D.2.4} Software, SOFTWARE ENGINEERING,
                 Software/Program Verification. {\bf F.3.1} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Jensen:1997:DPA,
  author =       "Thomas Jensen",
  title =        "Disjunctive Program Analysis for Algebraic Data
                 Types",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "5",
  pages =        "751--803",
  month =        sep,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Oct 26 07:58:06 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-5/p751-jensen/",
  abstract =     "We describe how binding-time data-flow, and strictness
                 analyses for languages with higher-order functions and
                 algebraic data types can be obtained by instantiating a
                 generic program logic and axiomatization of the
                 properties analyzed for. A distinctive feature of the
                 analyses is that disjunctions of program properties are
                 represented exactly. This yields analyses of high
                 precision and provides a logical characterization of
                 abstract interpretations involving tensor products and
                 uniform properties of recursive data structures. An
                 effective method for proving properties of a program
                 based on fixed-point iteration is obtained by grouping
                 logically equivalent formulae of the same type into
                 equivalence classes, obtaining a lattice of properties
                 of that type, and then defining an abstract
                 interpretation over these lattices. We demonstrate this
                 in the case of strictness analysis by proving that the
                 strictness abstract interpretation of a program is the
                 equivalence class containing the strongest property
                 provable of the program in the strictness logic.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf D.2.7} Software, SOFTWARE ENGINEERING,
                 Distribution, Maintenance, and Enhancement, SOFTLIB.
                 {\bf D.3.1} Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Semantics. {\bf D.3.2}
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative (functional) languages.
                 {\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Procedures, functions, and
                 subroutines. {\bf D.3.4} Software, PROGRAMMING
                 LANGUAGES, Processors, Compilers. {\bf E.1} Data, DATA
                 STRUCTURES, Lists, stacks, and queues. {\bf F.3.1}
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about Programs,
                 Logics of programs. {\bf F.3.2} Theory of Computation,
                 LOGICS AND MEANINGS OF PROGRAMS, Semantics of
                 Programming Languages, Denotational semantics.",
}

@Article{VanRoy:1997:MOD,
  author =       "Peter {Van Roy} and Seif Haridi and Per Brand and Gert
                 Smolka and Michael Mehl and Ralf Scheidhauer",
  title =        "Mobile Objects in {Distributed Oz}",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "5",
  pages =        "804--851",
  month =        sep,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 3 16:28:05 MST 1997",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-5/p804-van_roy/",
  abstract =     "Some of the most difficult questions to answer when
                 designing a distributed application are related to
                 mobility: what information to transfer between sites
                 and when and how to transfer it. Network-transparent
                 distribution, the property that a program's behavior is
                 independent of how it is partitioned among sites, does
                 not directly address these questions. Therefore we
                 propose to extend all language entities with a network
                 behavior that enables {\em efficient\/} distributed
                 programming by giving the programmer a simple and
                 predictable control over network communication
                 patterns. In particular, we show how to give object an
                 arbitrary mobility behavior that is independent of the
                 object definition. In this way, the syntax and
                 semantics of objects are the same regardless of whether
                 they are used as stationary servers, mobile agents, or
                 simply as caches. These ideas have been implemented in
                 Distributed Oz, a concurrent object-oriented language
                 that is state aware and has dataflow synchronization.
                 We prove that the implementation of objects in
                 Distributed Oz is network transparent. To satisfy the
                 predictability condition, the implementation avoids
                 forwarding chains through intermediate sites. The
                 implementation is an extension to the publicly
                 available DFKI Oz 2.0 system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.1.3} Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Distributed programming. {\bf
                 D.3.2} Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf F.3.2} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Semantics of Programming
                 Languages, Operational semantics.",
}

@Article{Moon:1997:PNC,
  author =       "Soo-Mook Moon and Kemal Ebcio{\u{g}}lu",
  title =        "Parallelizing nonnumerical code with selective
                 scheduling and software pipelining",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "853--898",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p853-moon/",
  abstract =     "Instruction-level parallelism (ILP) in nonnumerical
                 code is regarded as scarce and hard to exploit due to
                 its irregularity. In this article, we introduce a new
                 code-scheduling technique for irregular ILP called
                 ``selective scheduling'' which can be used as a
                 component for superscalar and VLIW compilers. Selective
                 scheduling can compute a wide set of independent
                 operations across {\em all\/} execution paths based on
                 renaming and forward-substitution and can compute
                 available operations across loop iterations if combined
                 with software pipelining. This scheduling approach has
                 better heuristics for determining the usefulness of
                 moving one operation versus moving another and can
                 successfully find useful code motions without resorting
                 to branch profiling. The compile-time overhead of
                 selective scheduling is low due to its incremental
                 computation technique and its controlled code
                 duplication. We parallelized the SPEC integer
                 benchmarks and five AIX utilities without using branch
                 probabilities. The experiments indicate that a fivefold
                 speedup is achievable on realistic resources with a
                 reasonable overhead in compilation time and code
                 expansion and that a solid speedup increase is also
                 obtainable on machines with fewer resources. These
                 results improve previously known characteristics of
                 irregular ILP.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; languages",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Raja:1997:CFC,
  author =       "N. Raja and R. K. Shyamasundar",
  title =        "Combinatory formulations of concurrent languages",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "899--915",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p899-raja/",
  abstract =     "We design a system with six {\em Basic Combinators\/}
                 and prove that it is powerful enough to embed the full
                 asynchronous $ \pi $-calculus, including replication.
                 Our theory for constructing {\em Combinatory
                 Versions\/} of concurrent languages is based on a
                 method, used by Quine and Bernays, for the general
                 elimination of variables in linguistic formalisms. Our
                 combinators are designed to eliminate the requirement
                 of {\em names\/} that are {\em bound\/} by an{\em input
                 prefix}. They also eliminate the need for input prefix,
                 output prefix, and the accompanying mechanism of {\em
                 substitution}. We define a notion of {\em
                 bisimulation\/} for the combinatory version and show
                 that the combinatory version preserves the semantics of
                 the original calculus. One of the distinctive features
                 of the approach is that it can be used to rework
                 several process algebras in order to derive equivalent
                 combinatory versions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf F.4.1} Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Lambda
                 calculus and related systems. {\bf I.1.3} Computing
                 Methodologies, SYMBOLIC AND ALGEBRAIC MANIPULATION,
                 Languages and Systems, Substitution mechanisms**. {\bf
                 F.1.2} Theory of Computation, COMPUTATION BY ABSTRACT
                 DEVICES, Modes of Computation, Parallelism and
                 concurrency.",
}

@Article{Sabry:1997:RCV,
  author =       "Amr Sabry and Philip Wadler",
  title =        "A reflection on a call-by-value",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "916--941",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p916-sabry/",
  abstract =     "One way to model a sound and complete translation from
                 a source calculus into a target calculus is with an
                 {\em adjoint\/} or a {\em Galois connection}. In the
                 special case of a {\em reflection}, one also has that
                 the target calculus is isomorphic to a subset of the
                 source. We show that three widely studied translations
                 form reflections. We use as our source language Moggi's
                 computational lambda calculus, which is an extension of
                 Plotkin's call-by-value calculus. We show that
                 Plotkin's CPS translation, Moggi's monad translation,
                 and Girard's translation to linear logic can all be
                 regarded as reflections form this source language, and
                 we put forward the computational lambda calculus as a
                 model of call-by-value computation that improves on the
                 traditional call-by-value calculus. Our work
                 strengthens Plotkin's and Moggi's original results and
                 improves on recent work based on{\em equational
                 correspondence}, which uses equations rather than
                 reductions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.1.1} Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf F.3.2} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages. {\bf
                 F.4.1} Theory of Computation, MATHEMATICAL LOGIC AND
                 FORMAL LANGUAGES, Mathematical Logic.",
}

@Article{Rinard:1997:CAN,
  author =       "Martin C. Rinard and Pedro C. Diniz",
  title =        "Commutativity analysis: a new analysis technique for
                 parallelizing compilers",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "942--991",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p942-rinard/",
  abstract =     "This article presents a new analysis technique,
                 commutativity analysis, for automatically parallelizing
                 computations that manipulate dynamic, pointer-based
                 data structures. Commutativity analysis views the
                 computation as composed of operations on objects. It
                 then analyzes the program at this granularity to
                 discover when operations commute (i.e., generate the
                 same final result regardless of the order in which they
                 execute). If all of the operations required to perform
                 a given computation commute, the compiler can
                 automatically generate parallel code. We have
                 implemented a prototype compilation system that uses
                 commutativity analysis as its primary analysis
                 technique. We have used this system to automatically
                 parallelize three complete scientific computations: the
                 Barnes--Hut N-body solver, the Water liquid simulation
                 code, and the String seismic simulation code. This
                 article presents performance results for the generate
                 parallel code running on the Stanford DASH machine.
                 These results provided encouraging evidence that
                 commutativity analysis can serve as the basis for a
                 successful parallelizing compiler. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors.",
}

@Article{Duesterwald:1997:PFD,
  author =       "Evelyn Duesterwald and Rajiv Gupta and Mary Lou
                 Soffa",
  title =        "A practical framework for demand-driven
                 interprocedural data flow analysis",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "992--1030",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p992-duesterwald/",
  abstract =     "The high cost and growing importance of
                 interprocedural data flow analysis have led to an
                 increased interest in demand-driven algorithms. In this
                 article, we present a general framework for developing
                 demand-driven interprocedural data flow analyzers and
                 report our experience in evaluating the performance of
                 this approach. A demand for data flow information is
                 modeled as a set of queries. The framework includes a
                 generic demand-driven algorithm that determines the
                 response to query by iteratively applying a system of
                 query propagation rules. The propagation rules yield
                 precise responses for the class of distributive finite
                 data flow problems. We also describe a two-phase
                 framework variation to accurately handle
                 nondistributive problems. A performance evaluation of
                 our demand-driven approach is presented for two data
                 flow problems, namely, reaching-definitions and copy
                 constant propagation. Our experiments show that
                 demand-driven analysis performs well in practice,
                 reducing both time and space requirements when compared
                 with exhaustive analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; performance",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.2.2} Software, SOFTWARE
                 ENGINEERING, Design Tools and Techniques. {\bf H.3.4}
                 Information Systems, INFORMATION STORAGE AND RETRIEVAL,
                 Systems and Software, Question-answering (fact
                 retrieval) systems**.",
}

@Article{Janssen:1997:MGR,
  author =       "Johan Janssen and Henk Corporaal",
  title =        "Making graphs reducible with controlled node
                 splitting",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "1031--1052",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p1031-janssen/",
  abstract =     "Several compiler optimizations, such as data flow
                 analysis, the exploitation of instruction-level
                 parallelism (ILP), loop transformations, and memory
                 disambiguation, require programs with reducible control
                 flow graphs. However, not all programs satisfy this
                 property. A new method for transforming irreducible
                 control flow graphs to reducible control flow graphs,
                 called Controlled Node Splitting (CNS), is presented.
                 CNS duplicates nodes of the control flow graph to
                 obtain reducible control flow graphs. CNS results in a
                 minimum number of splits and a minimum number of
                 duplicates. Sine the computation time to find the
                 optimal split sequence is large, a heuristic has been
                 developed. The results of this heuristic are close to
                 the optimum. Straightforward application of node
                 splitting resulted in an average code size increase of
                 235\% per procedure of our benchmark programs. CNS with
                 the heuristic limits this increase to only 3\%. The
                 impact on the total code size of the complete programs
                 is 13.6\% for a straightforward application of node
                 splitting. However, when CNS is used, with the
                 heuristic the average growth in code size of a complete
                 program dramatically reduces to 0.2\%",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf E.1} Data, DATA STRUCTURES,
                 Graphs and networks.",
}

@Article{Whitfield:1997:AEC,
  author =       "Deborah L. Whitfield and Mary Lou Soffa",
  title =        "An approach for exploring code improving
                 transformations",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "1053--1084",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p1053-whitfield/",
  abstract =     "Although code transformations are routinely applied to
                 improve the performance of programs for both scalar and
                 parallel machines, the properties of code-improving
                 transformations are not well understood. In this
                 article we present a framework that enables the
                 exploration, both analytically and experimentally, of
                 properties of code-improving transformations. The major
                 component of the framework is a specification language,
                 Gospel, for expressing the conditions needed to safely
                 apply a transformation and the actions required to
                 change the code to implement the transformation. The
                 framework includes a technique that facilitates an
                 analytical investigation of code-improving
                 transformations using the Gospel specifications. It
                 also contains a tool, Genesis, that automatically
                 produces a transformer that implements the
                 transformation specified in Gospel. We demonstrate the
                 usefulness of the framework by exploring the enabling
                 and disabling properties of transformations. We first
                 present analytical results on the enabling and
                 disabling properties of a set of code transformations,
                 including both traditional and parallelizing
                 transformations, and then describe experimental results
                 showing the types of transformations and the enabling
                 and disabling interactions actually found in a set of
                 programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; performance",
  subject =      "{\bf D.2.2} Software, SOFTWARE ENGINEERING, Design
                 Tools and Techniques. {\bf D.3.1} Software, PROGRAMMING
                 LANGUAGES, Formal Definitions and Theory, Semantics.
                 {\bf D.3.1} Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory, Syntax. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Code generation.
                 {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Translator writing systems and compiler generators.",
}

@Article{Yu:1997:NCI,
  author =       "Ting Yu and Owen Kaser",
  title =        "A note on {``On} the conversion of indirect to direct
                 recursion''",
  journal =      j-TOPLAS,
  volume =       "19",
  number =       "6",
  pages =        "1085--1087",
  month =        nov,
  year =         "1997",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Mar 11 18:11:48 MST 1998",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1997-19-6/p1085-yu/",
  abstract =     "In the article ``On the conversion of indirect to
                 direct recursion''(ACM Lett. Program. Lang. 2, 1-4. pp.
                 151-164), a method was introduced to convert indirect
                 to direct recursion. It was claimed that for any call
                 graph, there is a mutual-recursion elimination sequence
                 if and only if no strongly connected component contains
                 two node-disjoint circuits. We first give a
                 counterexample and then provide a correction.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers.",
}

@Article{Sagiv:1998:SSA,
  author =       "Mooly Sagiv and Thomas Reps and Reinhard Wilhelm",
  title =        "Solving shape-analysis problems in languages with
                 destructive updating",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "1",
  pages =        "1--50",
  month =        jan,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-1/p1-sagiv/",
  abstract =     "This article concerns the static analysis of programs
                 that perform destructive updating on heap-allocated
                 storage. We give an algorithm that uses finite shape
                 graphs to approximate conservatively the possible
                 ``shapes'' that heap-allocated structures in a program
                 can take on. For certain programs, our technique is
                 able to determine such properties as (1) when the input
                 to the program is a list, the output is also a list and
                 (2) when the input to the program is a tree, the output
                 is also a tree. For example, the method can determine
                 that ``listness'' is preserved by (1) a program that
                 performs list reversal via destructive updating of the
                 input list and (2) a program that searches a list and
                 splices a new element into the list. None of the
                 previously known methods that use graphs to model the
                 program's store are capable of determining that
                 ``listness'' is preserved on these examples (or
                 examples of similar complexity). In contrast with most
                 previous work, our shape analysis algorithm is even
                 accurate for certain programs that update cyclic data
                 structures; that is, it is sometimes able to show that
                 when the input to the program is a circular list, the
                 output is also a circular list. For example, the
                 shape-analysis algorithm can determine that an
                 insertion into a circular list preserves ``circular
                 listness.''",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory; verification",
  subject =      "{\bf F.3.2} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Semantics of Programming Languages,
                 Program analysis. {\bf D.2.5} Software, SOFTWARE
                 ENGINEERING, Testing and Debugging, Symbolic execution.
                 {\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf E.1} Data, DATA
                 STRUCTURES, Graphs and networks. {\bf F.3.3} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Type structure. {\bf E.1} Data,
                 DATA STRUCTURES, Lists, stacks, and queues. {\bf E.1}
                 Data, DATA STRUCTURES, Trees. {\bf E.2} Data, DATA
                 STORAGE REPRESENTATIONS, Linked representations.",
}

@Article{Attie:1998:SCS,
  author =       "Paul C. Attie and E. Allen Emerson",
  title =        "Synthesis of concurrent systems with many similar
                 processes",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "1",
  pages =        "51--115",
  month =        jan,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-1/p51-attie/",
  abstract =     "Methods for synthesizing concurrent programs from
                 temporal logic specifications based on the use of a
                 decision procedure for testing temporal satisfiability
                 have been proposed by Emerson and Clarke and by Manna
                 and Wolper. An important advantage of these synthesis
                 methods is that they obviate the need to manually
                 compose a program and manually construct a proof of its
                 correctness. One only has to formulate a precise
                 problem specification; the synthesis method then
                 mechanically constructs a correct solution. A serious
                 drawback of these methods in practice, however, is that
                 they suffer from the state explosion problem. To
                 synthesize a concurrent system consisting of $K$
                 sequential processes, each having $N$ states in its
                 local transition diagram, requires construction of the
                 global product-machine having about {\em NK\/} global
                 states in general. This exponential growth in $K$ makes
                 it infeasible to synthesize systems composed of more
                 than 2 or 3 processes. In this article, we show how to
                 synthesize concurrent systems consisting of many (i.e.,
                 a finite but arbitrarily large number $K$ of) similar
                 sequential processes. Our approach avoids construction
                 of the global product-machine for $K$ processes;
                 instead, it constructs a two-process product-machine
                 for a single pair of generic sequential processes. The
                 method is uniform in $K$, providing a simple template
                 that can be instantiated for each process to yield a
                 solution for any fixed $K$. The method is also
                 illustrated on synchronization problems from the
                 literature.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf C.2.4} Computer Systems Organization,
                 COMPUTER-COMMUNICATION NETWORKS, Distributed Systems.
                 {\bf D.1.2} Software, PROGRAMMING TECHNIQUES, Automatic
                 Programming. {\bf D.1.3} Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming. {\bf D.2.4}
                 Software, SOFTWARE ENGINEERING, Software/Program
                 Verification. {\bf F.3.1} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs, Mechanical verification. {\bf
                 I.2.2} Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 synthesis.",
}

@Article{Dujardin:1998:FAC,
  author =       "Eric Dujardin and Eric Amiel and Eric Simon",
  title =        "Fast algorithms for compressed multimethod dispatch
                 table generation",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "1",
  pages =        "116--165",
  month =        jan,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-1/p116-dujardin/",
  abstract =     "The efficiency of dynamic dispatch is a major
                 impediment to the adoption of multimethods in
                 object-oriented languages. In this article, we propose
                 a simple multimethod dispatch scheme based on
                 compressed dispatch tables. This scheme is applicable
                 to any object-oriented language using a method
                 precedence order that satisfies a specific monotonous
                 property (e.g., as Cecil and Dylan) and guarantees that
                 dynamic dispatch is performed in constant time, the
                 latter being a major requirement for some languages and
                 applications. We provide efficient algorithms to build
                 the dispatch tables, provide their worst-case
                 complexity, and demonstrate the effectiveness of our
                 scheme by real measurements performed on two large
                 object-oriented applications. Finally, we provide a
                 detailed comparison of our technique with other
                 existing techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; measurement; performance",
  subject =      "{\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Control structures. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf D.3.3} Software, PROGRAMMING
                 LANGUAGES, Language Constructs and Features,
                 Procedures, functions, and subroutines. {\bf E.1} Data,
                 DATA STRUCTURES. {\bf E.2} Data, DATA STORAGE
                 REPRESENTATIONS.",
}

@Article{Wright:1998:PSE,
  author =       "Andrew K. Wright and Suresh Jagannathan",
  title =        "Polymorphic splitting: an effective polyvariant flow
                 analysis",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "1",
  pages =        "166--207",
  month =        jan,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-1/p166-wright/",
  abstract =     "This article describes a general-purpose program
                 analysis that computes global control-flow and
                 data-flow information for higher-order, call-by-value
                 languages. The analysis employs a novel form of
                 polyvariance called polymorphic splitting that uses
                 let-expressions as syntactic clues to gain precision.
                 The information derived from the analysis is used both
                 to eliminate run-time checks and to inline procedures.
                 The analysis and optimizations have been applied to a
                 suite of Scheme programs. Experimental results obtained
                 from the prototype implementation indicate that the
                 analysis is extremely precise and has reasonable cost.
                 Compared to monovariant flow analyses such as 0CFA, or
                 analyses based on type inference such as soft typing,
                 the analysis eliminates significantly more run-time
                 checks. Run-time check elimination and inlining
                 together typically yield a 20 to 40\% performance
                 improvement for the benchmark suite, with some programs
                 running four times as fast.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "experimentation; performance",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf D.3.2} Software,
                 PROGRAMMING LANGUAGES, Language Classifications,
                 Applicative (functional) languages.",
}

@Article{Leuschel:1998:CGP,
  author =       "Michael Leuschel and Bern Martens and Danny {De
                 Schreye}",
  title =        "Controlling generalization and polyvariance in partial
                 deduction of normal logic programs",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "1",
  pages =        "208--258",
  month =        jan,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 26 15:58:11 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-1/p208-leuschel/",
  abstract =     "Given a program and some input data, partial deduction
                 computes a specialized program handling any remaining
                 input more efficiently. However, controlling the
                 process well is a rather difficult problem. In this
                 article, we elaborate global control for partial
                 deduction: for which atoms, among possibly infinitely
                 many, should specialized relations be produced,
                 meanwhile guaranteeing correctness as well as
                 termination. Our work is based on two ingredients.
                 First, we use the concept of a characteristic tree,
                 encapsulating specialization behavior rather than
                 syntactic structure, to guide generalization and
                 polyvariance, and we show how this can be done in a
                 correct and elegant way. Second, we structure
                 combinations of atoms and associated characteristic
                 trees in global trees registering ``causal''
                 relationships among such pairs. This allows us to spot
                 looming nontermination and perform proper
                 generalization in order to avert the danger, without
                 having to impose a depth bound on characteristic trees.
                 The practical relevance and benefits of the work are
                 illustrated through extensive experiments. Finally, a
                 similar approach may improve upon current (on-line)
                 control strategies for program transformation in
                 general such as (positive) supercompilation of
                 functional programs. It also seems valuable in the
                 context of abstract interpretation to handle infinite
                 domains of infinite height with more precision.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf D.1.2} Software, PROGRAMMING TECHNIQUES,
                 Automatic Programming. {\bf I.2.3} Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving, Logic programming. {\bf D.1.6}
                 Software, PROGRAMMING TECHNIQUES, Logic Programming.
                 {\bf F.4.1} Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Logic and
                 constraint programming. {\bf I.2.2} Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming.",
}

@Article{Reps:1998:MMT,
  author =       "Thomas Reps",
  title =        "{``Maximal-munch''} tokenization in linear time",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "259--273",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p259-reps/",
  abstract =     "The lexical-analysis (or scanning) phase of a compiler
                 attempts to partition an input string into a sequence
                 of tokens. The convention in most languages is that the
                 input is scanned left to right, and each token
                 identified is a ``maximal munch'' of the remaining
                 input---the {\em longest\/} prefix of the remaining
                 input that is a token of the language. Although most of
                 the standard compiler textbooks present a way to
                 perform maximal-munch tokenization, the algorithm they
                 describe is one that, for certain sets of token
                 definitions, can cause the scanner to exhibit quadratic
                 behavior in the worst case. In the article, we show
                 that maximal-munch tokenization can always be performed
                 in time linear in the size of the input.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf F.1.1} Theory of
                 Computation, COMPUTATION BY ABSTRACT DEVICES, Models of
                 Computation, Automata. {\bf F.2.2} Theory of
                 Computation, ANALYSIS OF ALGORITHMS AND PROBLEM
                 COMPLEXITY, Nonnumerical Algorithms and Problems,
                 Pattern matching. {\bf I.5.4} Computing Methodologies,
                 PATTERN RECOGNITION, Applications, Text processing.",
}

@Article{Lang:1998:SAE,
  author =       "Jun Lang and David B. Stewart",
  title =        "A study of the applicability of existing
                 exception-handling techniques to component-base
                 real-time software technology",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "274--301",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p274-lang/",
  abstract =     "This study focuses on the current state of
                 error-handling technology and concludes with
                 recommendations for further research in error handling
                 for component-based real-time software. With real-time
                 programs growing in size and complexity, the quality
                 and cost of developing and maintaining them are still
                 deep concerns to embedded software industries.
                 Component-based software is a promising approach in
                 reducing development cost while increasing quality and
                 reliability. As with any other real-time software,
                 component-based software needs exception detection and
                 handling mechanisms to satisfy reliability
                 requirements. The current lack of suitable
                 error-handling techniques can make an application
                 composed of reusable software nondeterministic and
                 difficult to understand in the presence of errors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design; languages; performance; standardization",
  subject =      "{\bf D.2.10} Software, SOFTWARE ENGINEERING, Design**.
                 {\bf D.2.3} Software, SOFTWARE ENGINEERING, Coding
                 Tools and Techniques. {\bf D.2.6} Software, SOFTWARE
                 ENGINEERING, Programming Environments. {\bf D.3.3}
                 Software, PROGRAMMING LANGUAGES, Language Constructs
                 and Features. {\bf D.4.1} Software, OPERATING SYSTEMS,
                 Process Management. {\bf D.4.7} Software, OPERATING
                 SYSTEMS, Organization and Design, Real-time systems and
                 embedded systems. {\bf D.4.8} Software, OPERATING
                 SYSTEMS, Performance. {\bf D.4.9} Software, OPERATING
                 SYSTEMS, Systems Programs and Utilities.",
}

@Article{Jackson:1998:IFM,
  author =       "Daniel Jackson and Somesh Jha and Craig A. Damon",
  title =        "Isomorph-free model enumeration: a new method for
                 checking relational specifications",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "302--343",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p302-jackson/",
  abstract =     "Software specifications often involve data structures
                 with huge numbers of value, and consequently they
                 cannot be checked using standard state exploration or
                 model-checking techniques. Data structures can be
                 expressed with binary relations, and operations over
                 such structures can be expressed as formulae involving
                 relational variables. Checking properties such as
                 preservation of an invariant thus reduces to
                 determining the validity of a formula or, equivalently,
                 finding a model (of the formula's negation). A new
                 method for finding relational models is presented. It
                 exploits the permutation invariance of models---if two
                 interpretations are isomorphic, then neither is a
                 model, or both are---by partitioning the space into
                 equivalence classes of symmetrical interpretations.
                 Representatives of these classes are constructed
                 incrementally by using the symmetry of the partial
                 interpretation to limit the enumeration of new relation
                 values. The notion of symmetry depends on the type
                 structure of the formula; by picking the weakest
                 typing, larger equivalence classes (and thus fewer
                 representatives) are obtained. A more refined notion of
                 symmetry that exploits the meaning of the relational
                 operators is also described. The method typically leads
                 to exponential reductions; in combination with other,
                 simpler, reductions it makes automatic analysis of
                 relational specifications possible for the first
                 time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; verification",
  subject =      "{\bf D.2.4} Software, SOFTWARE ENGINEERING,
                 Software/Program Verification. {\bf D.2.1} Software,
                 SOFTWARE ENGINEERING, Requirements/Specifications. {\bf
                 D.2.5} Software, SOFTWARE ENGINEERING, Testing and
                 Debugging. {\bf F.3.1} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Specifying and Verifying and
                 Reasoning about Programs.",
}

@Article{Douence:1998:SSF,
  author =       "R{\'e}mi Douence and Pascal Fradet",
  title =        "A systematic study of functional language
                 implementations",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "344--387",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p344-douence/",
  abstract =     "We introduce a unified framework to describe, relate,
                 compare, and classify functional language
                 implementations. The compilation process is expressed
                 as a succession of program transformations in the
                 common framework. At each step, different
                 transformations model fundamental choices. A benefit of
                 this approach is to structure and decompose the
                 implementation process. The correctness proofs can be
                 tackled independently for each step and amount to
                 proving program transformations in the functional
                 world. This approach also paves the way to formal
                 comparisons by making it possible to estimate the
                 complexity of individual transformations or
                 compositions of them. Our study aims at covering the
                 whole known design space of sequential functional
                 language implementations. In particular, we consider
                 call-by-value, call-by-name, call-by-need reduction
                 strategies as well as environment- and graph-based
                 implementations. We describe for each compilation step
                 the diverse alternatives as program transformations. In
                 some cases, we illustrate how to compare or relate
                 compilation techniques, express global optimizations,
                 or hybrid implementations. We also provide a
                 classification of well-known abstract machines.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory; verification",
  subject =      "{\bf D.1.1} Software, PROGRAMMING TECHNIQUES,
                 Applicative (Functional) Programming. {\bf D.2.4}
                 Software, SOFTWARE ENGINEERING, Software/Program
                 Verification, Correctness proofs. {\bf D.2.8} Software,
                 SOFTWARE ENGINEERING, Metrics, Complexity measures.
                 {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Code generation. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf F.4.1} Theory of Computation,
                 MATHEMATICAL LOGIC AND FORMAL LANGUAGES, Mathematical
                 Logic, Lambda calculus and related systems.",
}

@Article{Sreedhar:1998:NFE,
  author =       "Vugranam C. Sreedhar and Guang R. Gao and Yong-Fong
                 Lee",
  title =        "A New Framework for Elimination-Based Data Flow
                 Analysis Using {DJ} Graphs",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "388--435",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 2 10:46:05 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p388-sreedhar/",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization. {\bf
                 E.1} Data, DATA STRUCTURES, Graphs and networks. {\bf
                 E.1} Data, DATA STRUCTURES, Trees.",
}

@Article{Kobayashi:1998:PDF,
  author =       "Naoki Kobayashi",
  title =        "A Partially Deadlock-Free Typed Process Calculus",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "2",
  pages =        "436--482",
  month =        mar,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-2/p436-kobayashi/",
  abstract =     "We propose a novel static type system for a process
                 calculus, which ensures both partial deadlock-freedom
                 and partial confluence. The key novel ideas are (1)
                 introduction to the order of channel use as type
                 information, and (2) classification of communication
                 channels into reliable and unreliable channels based on
                 their usage and a guarantee of the usage by the type
                 system. We can ensure that communication on reliable
                 channels never causes deadlock and also that certain
                 reliable channels never introduce nondeterminism. After
                 presenting the type system and formal proofs of its
                 correctness, we show encodings of the $ \lambda
                 $-calculus and typical concurrent objects in the
                 deadlock-free fragment of the calculus and demonstrate
                 how type information can be used for reasoning about
                 program behavior.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.1} Software, PROGRAMMING LANGUAGES, Formal
                 Definitions and Theory. {\bf D.3.3} Software,
                 PROGRAMMING LANGUAGES, Language Constructs and
                 Features.",
}

@Article{Rinard:1998:DIE,
  author =       "Martin C. Rinard and Monica S. Lam",
  title =        "The Design, Implementation, and Evaluation of {Jade}",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "3",
  pages =        "483--545",
  month =        may,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-3/p483-rinard/",
  abstract =     "Jade is a portable, implicitly parallel language
                 designed for exploiting task-level concurrency.Jade
                 programmers start with a program written in a standard
                 serial, imperative language, then use Jade constructs
                 to declare how parts of the program access data. The
                 Jade implementation uses this data access information
                 to automatically extract the concurrency and map the
                 application onto the machine at hand. The resulting
                 parallel execution preserves the semantics of the
                 original serial program. We have implemented Jade as an
                 extension to C, and Jade implementations exist for
                 shared-memory multiprocessors, homogeneous
                 message-passing machines, and heterogeneous networks of
                 workstations. In this article we discuss the design
                 goals and decisions that determined the final form of
                 Jade and present an overview of the Jade
                 implementation. We also present our experience using
                 Jade to implement several complete scientific and
                 engineering applications. We use this experience to
                 evaluate how the different Jade language features were
                 used in practice and how well Jade as a whole supports
                 the process of developing parallel applications. We
                 find that the basic idea of preserving the serial
                 semantics simplifies the program development process,
                 and that the concept of using data access
                 specifications to guide the parallelization offers
                 significant advantages over more traditional
                 control-based approaches. We also find that the Jade
                 data model can interact poorly with concurrency
                 patterns that write disjoint pieces of a single
                 aggregate data structure, although this problem arises
                 in only one of the applications.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.1.3} Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Parallel programming. {\bf
                 D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Concurrent programming
                 structures.",
}

@Article{Liu:1998:SCI,
  author =       "Yanhong A. Liu and Scott D. Stoller and Tim
                 Teitelbaum",
  title =        "Static Caching for Incremental Computation",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "3",
  pages =        "546--585",
  month =        may,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-3/p546-liu/",
  abstract =     "A systematic approach is given for deriving
                 incremental programs that exploit caching. The
                 cache-and-prune method presented in the article
                 consists of three stages: (I) the original program is
                 extended to cache the results of all its intermediate
                 subcomputations as well as the final result, (II) the
                 extended program is incrementalized so that computation
                 on a new input can use all intermediate results on an
                 old input, and (III) unused results cached by the
                 extended program and maintained by the incremental
                 program are pruned away, leaving a pruned extended
                 program that caches only useful intermediate results
                 and a pruned incremental program that uses and
                 maintains only useful results. All three stages utilize
                 static analyses and semantics-preserving
                 transformations. Stages I and III are simple, clean,
                 and fully automatable. The overall method has a kind of
                 optimality with respect to the techniques used in Stage
                 II. The method can be applied straightforwardly to
                 provide a systematic approach to program improvement
                 via caching.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf I.2.2} Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Automatic analysis of algorithms. {\bf
                 D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features. {\bf F.3.3} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs. {\bf I.2.2} Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Automatic
                 Programming, Program transformation.",
}

@Article{Sagonas:1998:AMT,
  author =       "Konstantinos Sagonas and Terrance Swift",
  title =        "An Abstract Machine for Tabled Execution of
                 Fixed-Order Stratified Logic Programs",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "3",
  pages =        "586--634",
  month =        may,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-3/p586-sagonas/",
  abstract =     "SLG resolution uses tabling to evaluate nonfloundering
                 normal logic programs according to the well-founded
                 semantics. The SLG-WAM, which forms the engine of the
                 XSB system, can compute in-memory recursive queries an
                 order of magnitude faster than current deductive
                 databases. At the same time, the SLG-WAM tightly
                 integrates Prolog code with tabled SLG code, and
                 executes Prolog code with minimal overhead compared to
                 the WAM. As a result, the SLG-WAM brings to logic
                 programming important termination and complexity
                 properties of deductive databases. This article
                 describes the architecture of the SLG-WAM for a
                 powerful class of programs, the class of fixed-order
                 dynamically stratified programs. We offer a detailed
                 description of the algorithms, data structures, and
                 instructions that the SLG-WAM adds to the WAM, and a
                 performance analysis of engine overhead due to the
                 extensions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; performance",
  subject =      "{\bf D.1.6} Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.1.2} Software, PROGRAMMING
                 TECHNIQUES, Automatic Programming. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors, Compilers.
                 {\bf F.4.1} Theory of Computation, MATHEMATICAL LOGIC
                 AND FORMAL LANGUAGES, Mathematical Logic, Logic and
                 constraint programming. {\bf I.2.3} Computing
                 Methodologies, ARTIFICIAL INTELLIGENCE, Deduction and
                 Theorem Proving, Logic programming. {\bf I.2.3}
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Deduction and Theorem Proving, Nonmonotonic reasoning
                 and belief revision. {\bf D.3.4} Software, PROGRAMMING
                 LANGUAGES, Processors, Interpreters. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf I.2.3} Computing Methodologies,
                 ARTIFICIAL INTELLIGENCE, Deduction and Theorem Proving,
                 Resolution.",
}

@Article{Pugh:1998:CBA,
  author =       "William Pugh and David Wonnacott",
  title =        "Constraint-Based Array Dependence Analysis",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "3",
  pages =        "635--678",
  month =        may,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-3/p635-pugh/",
  abstract =     "Traditional array dependence analysis, which detects
                 potential memory aliasing of array references is a key
                 analysis technique for automatic parallelization.
                 Recent studies of benchmark codes indicate that
                 limitations of analysis cause many compilers to
                 overlook large amounts of potential parallelism, and
                 that exploiting this parallelism requires algorithms to
                 answer new question about array references, not just
                 get better answers to the old questions of aliasing. We
                 need to ask about the flow of values in arrays, to
                 check the legality of array privatization, and about
                 the conditions under which a dependence exists, to
                 obtain information about conditional parallelism. In
                 some cases, we must answer these questions about code
                 containing nonlinear terms in loop bounds or
                 subscripts. This article describes techniques for
                 phrasing these questions in terms of systems of
                 constraints. Conditional dependence analysis can be
                 performed with a constraint operation we call the
                 ``gist'' operation. When subscripts and loop bounds are
                 affine, questions about the flow of values in array
                 variables can be phrased in terms of Presburger
                 Arithmetic. When the constraints describing a
                 dependence are not affine, we introduce uninterpreted
                 function symbols to represent the nonaffine terms. Our
                 constraint language also provides a rich language for
                 communication with the dependence analyzer, by either
                 the programmer or other phases of the compiler. This
                 article also documents our investigations of the
                 practicality of our approach. The worst-case complexity
                 of Presburger Arithmetic indicates that it might be
                 unsuitable for any practical application. However, we
                 have found that analysis of benchmark programs does not
                 cause the exponential growth in the number of
                 constraints that could occur in the worst case. We have
                 studied the constraints produced during our analysis,
                 and identified characteristics that keep our algorithms
                 free of exponential behavior in practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Fokkink:1998:WAR,
  author =       "Wan Fokkink and Jasper Kamperman and Pum Walters",
  title =        "Within {ARM}'s Reach: Compilation of Left-Linear
                 Rewrite Systems via Minimal Rewrite Systems",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "3",
  pages =        "679--706",
  month =        may,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-3/p679-fokkink/",
  abstract =     "A new compilation technique for left-linear
                 term-rewriting systems is presented, where rewrite
                 rules are transformed into so-called minimal rewrite
                 rules. These minimal rules have such a simple form that
                 they can be viewed as instructions for an abstract
                 rewriting machine (ARM).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Optimization.",
}

@Article{Lee:1998:PAF,
  author =       "Oukseh Lee and Kwangkeun Yi",
  title =        "Proofs about a Folklore Let-Polymorphic Type Inference
                 Algorithm",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "4",
  pages =        "707--723",
  month =        jul,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-4/p707-lee/",
  abstract =     "The Hindley/Milner let-polymorphic type inference
                 system has two different algorithms: one is the de
                 facto standard Algorithm *** that is bottom-up (or
                 context-insensitive), and the other is a ``folklore''
                 algorithm that is top-down (or context-sensitive).
                 Because the latter algorithm has not been formally
                 presented with its soundness and completeness proofs,
                 and its relation with the *** algorithm has not been
                 rigorously investigated, its use in place of (or in
                 combination with) *** is not well founded. In this
                 article, we formally define the context-sensitive,
                 top-down type inference algorithm (named ``***''),
                 prove its soundness and completeness, and show a
                 distinguishing property that *** always stops earlier
                 than *** if the input program is ill typed. Our proofs
                 can be seen as theoretical justifications for various
                 type-checking strategies being used in practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Data types and structures.
                 {\bf F.3.3} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs, Type
                 structure.",
}

@Article{Tofte:1998:RIA,
  author =       "Mads Tofte and Lars Birkedal",
  title =        "A Region Inference Algorithm",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "4",
  pages =        "724--767",
  month =        jul,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-4/p724-tofte/",
  abstract =     "Region Inference is a program analysis which infers
                 lifetimes of values. It is targeted at a runtime model
                 in which the store consists of a stack of regions and
                 memory management predominantly consists of pushing and
                 popping regions, rather than performing garbage
                 collection. Region Inference has previously been
                 specified by a set of inference rules which formalize
                 when regions may be allocated and deallocated. This
                 article presents an algorithm which implements the
                 specification. We prove that the algorithm is sound
                 with respect to the region inference rules and that it
                 always terminates even though the region inference
                 rules permit polymorphic recursion in regions. The
                 algorithm is the result of several years of experiments
                 with region inference algorithms in the ML Kit, a
                 compiler from Standard ML to assembly language. We
                 report on practical experience with the algorithm and
                 give hints on how to implement it.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; reliability; theory",
  subject =      "{\bf D.3.3} Software, PROGRAMMING LANGUAGES, Language
                 Constructs and Features, Dynamic storage management.
                 {\bf F.3.3} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs, Functional
                 constructs. {\bf F.3.3} Theory of Computation, LOGICS
                 AND MEANINGS OF PROGRAMS, Studies of Program
                 Constructs, Type structure.",
}

@Article{Alpuente:1998:PEF,
  author =       "Mar{\'\i}a Alpuente and Moreno Falaschi and Germ{\'a}n
                 Vidal",
  title =        "Partial Evaluation of Functional Logic Programs",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "4",
  pages =        "768--844",
  month =        jul,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-4/p768-alpuente/",
  abstract =     "Languages that integrate functional and logic
                 programming with a complete operational semantics are
                 based on narrowing, a unification-based goal-solving
                 mechanism which subsumes the reduction principle of
                 functional languages and the resolution principle of
                 logic languages. In this article, we present a partial
                 evaluation scheme for functional logic languages based
                 on an automatic unfolding algorithm which builds
                 narrowing trees. The method is formalized within the
                 theoretical framework established by Lloyd and
                 Shepherdson for the partial deduction of logic
                 programs, which we have generalized for dealing with
                 functional computations. A generic specialization
                 algorithm is proposed which does not depend on the
                 eager or lazy nature of the narrower being used. To the
                 best of our knowledge, this is the first generic
                 algorithm for the specialization of functional logic
                 programs. We also discuss the relation to work on
                 partial evaluation in functional programming,
                 term-rewriting systems, and logic programming. Finally,
                 we present some experimental results with an
                 implementation of the algorithm which show in practice
                 that the narrowing-driven partial evaluator effectively
                 combines the propagation of partial data structures (by
                 means of logical variables and unification) with better
                 opportunities for optimization (thanks to the
                 functional dimension).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance; theory",
  subject =      "{\bf D.1.6} Software, PROGRAMMING TECHNIQUES, Logic
                 Programming. {\bf D.1.1} Software, PROGRAMMING
                 TECHNIQUES, Applicative (Functional) Programming. {\bf
                 I.2.2} Computing Methodologies, ARTIFICIAL
                 INTELLIGENCE, Automatic Programming, Program
                 transformation. {\bf D.3.2} Software, PROGRAMMING
                 LANGUAGES, Language Classifications.",
}

@Article{Ashley:1998:PFF,
  author =       "J. Michael Ashley and R. Kent Dybvig",
  title =        "A Practical and Flexible Flow Analysis for
                 Higher-Order Languages",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "4",
  pages =        "845--868",
  month =        jul,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-4/p845-ashley/",
  abstract =     "A flow analysis collects data-flow and control-flow
                 information about programs. A compiler can use this
                 information to enable optimizations. The analysis
                 described in this article unifies and extends previous
                 work on flow analysis for higher-order languages
                 supporting assignment and control operators. The
                 analysis is abstract interpretation based and is
                 parameterized over two polyvariance operators and a
                 projection operator. These operators are used to
                 regulate the speed and accuracy of the analysis. An
                 implementation of the analysis is incorporated into and
                 used in a production Scheme compiler. The analysis can
                 process any legal Scheme program without modification.
                 Others have demonstrated that a 0CFA analysis can
                 enables the optimizations, but a 0CFA analysis is $
                 O(n^3) $. An $ O(n) $ instantiation of our analysis
                 successfully enables the optimization of closure
                 representations and procedure calls. Experiments with
                 the cheaper instantiation show that it is as effective
                 as 0CFA for these optimizations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization.",
}

@Article{Kennedy:1998:ADL,
  author =       "Ken Kennedy and Ulrich Kremer",
  title =        "Automatic Data Layout for Distributed-Memory
                 Machines",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "4",
  pages =        "869--916",
  month =        jul,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-4/p869-kennedy/",
  abstract =     "The goal of languages like Fortran D or High
                 Performance Fortran (HPF) is to provide a simple yet
                 efficient machine-independent parallel programming
                 model. After the algorithm selection, the data layout
                 choice is the key intellectual challenge in writing an
                 efficient program in such languages. The performance of
                 a data layout depends on the target compilation system,
                 the target machine, the problem size, and the number of
                 available processors. This makes the choice of a good
                 layout extremely difficult for most users of such
                 languages. If languages such as HPF are to find general
                 acceptance, the need for data layout selection support
                 has to be addressed. We believe that the appropriate
                 way to provide the needed support is through a tool
                 that generates data layout specifications
                 automatically. This article discusses the design and
                 implementation of a data layout selection tool that
                 generates HPF-style data layout specifications
                 automatically. Because layout is done in a tool that is
                 not embedded in the target compiler and hence will be
                 run only a few times during the tuning phase of an
                 application, it can use techniques such as integer
                 programming that may be considered too computationally
                 expensive for inclusion in production compilers. The
                 proposed framework for automatic data layout selection
                 builds and examines search spaces of candidate data
                 layouts. A candidate layout is an efficient layout for
                 some part of the program. After the generation of
                 search spaces, a single candidate layout is selected
                 for each program part, resulting in a data layout for
                 the entire program. A good overall data layout may
                 require the remapping of arrays between program parts.
                 A performance estimator based on a compiler model, an
                 execution model, and a machine model are needed to
                 predict the execution time of each candidate layout and
                 the costs of possible remappings between candidate data
                 layouts. In the proposed framework, instances of
                 NP-complete problems are solved during the construction
                 of candidate layout search spaces and the final
                 selection of candidate layouts from each search space.
                 Rather than resorting to heuristics, the framework
                 capitalizes on state-of-the-art 0-1 integer programming
                 technology to compute optimal solutions of these
                 NP-complete problems. A prototype data layout assistant
                 tool based on our framework has been implemented as
                 part of the D system currently under development at
                 Rice University. The article reports preliminary
                 experimental results. The results indicate that the
                 framework is efficient and allows the generation of
                 data layouts of high quality.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf C.1.2} Computer Systems
                 Organization, PROCESSOR ARCHITECTURES, Multiple Data
                 Stream Architectures (Multiprocessors). {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization. {\bf E.1} Data, DATA STRUCTURES, Arrays.
                 {\bf G.1.6} Mathematics of Computing, NUMERICAL
                 ANALYSIS, Optimization, Integer programming. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Optimization.",
}

@Article{Juan:1998:CVC,
  author =       "Eric Y. T. Juan and Jeffrey J. P. Tsai and Tadao
                 Murata",
  title =        "Compositional Verification of Concurrent Systems Using
                 {Petri}-Net-Based Condensation Rules",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "5",
  pages =        "917--979",
  month =        sep,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-5/p917-juan/",
  abstract =     "The state-explosion problem of formal verification has
                 obstructed its application to large-scale software
                 systems. In this article, we introduce a set of new
                 condensation theories: IOT-failure equivalence,
                 IOT-state equivalence, and firing-dependence theory to
                 cope with this problem. Our condensation theories are
                 much weaker than current theories used for the
                 compositional verification of Petri nets. More
                 significantly, our new condensation theories can
                 eliminate the interleaved behaviors caused by
                 asynchronously sending actions. Therefore, our
                 technique provides a much more powerful means for the
                 compositional verification of asynchronous processes.
                 Our technique can efficiently analyze several
                 state-based properties: boundedness, reachable
                 markings, reachable submarkings, and deadlock states.
                 Based on the notion of our new theories, we develop a
                 set of condensation rules for efficient verification of
                 large-scale software systems. The experimental results
                 show a significant improvement in the analysis
                 large-scale concurrent systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; experimentation; reliability; theory;
                 verification",
  subject =      "{\bf D.2.4} Software, SOFTWARE ENGINEERING,
                 Software/Program Verification, Programming by contract.
                 {\bf F.3.1} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Specifying and Verifying and Reasoning
                 about Programs, Mechanical verification.",
}

@Article{Wagner:1998:EFI,
  author =       "Tim A. Wagner and Susan L. Graham",
  title =        "Efficient and Flexible Incremental Parsing",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "5",
  pages =        "980--1013",
  month =        sep,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-5/p980-wagner/",
  abstract =     "Previously published algorithms for LR ($k$)
                 incremental parsing are inefficient, unnecessarily
                 restrictive, and in some cases incorrect. We present a
                 simple algorithm based on parsing LR($k$) sentential
                 forms that can incrementally parse an arbitrary number
                 of textual and/or structural modifications in optimal
                 time and with no storage overhead. The central role of
                 {\em balanced sequences\/} in achieving truly
                 incremental behavior from analysis algorithms is
                 described, along with automated methods to support
                 balancing during parse table generation and parsing.
                 Our approach extends the theory of sentential-form
                 parsing to allow for {\em ambiguity\/} in the grammar,
                 exploiting it for notational convenience, to denote
                 sequences, and to construct compact (``abstract'')
                 syntax trees directly. Combined, these techniques make
                 the use of automatically generated incremental parsers
                 in interactive software development environments both
                 practical and effective. In addition, we address {\em
                 information preservation\/} in these environments:
                 Optimal node reuse is defined; previous definitions are
                 shown to be insufficient; and a method for detecting
                 node reuse is provided that is both simpler and faster
                 than existing techniques. A program representation
                 based on {\em self-versioning documents\/} is used to
                 detect changes in the program, generate efficient
                 change reports for subsequent analyses, and allow the
                 parsing transformation itself to be treated as a
                 reversible modification in the edit log.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf D.2.6} Software, SOFTWARE ENGINEERING,
                 Programming Environments, Interactive environments.
                 {\bf D.2.7} Software, SOFTWARE ENGINEERING,
                 Distribution, Maintenance, and Enhancement, Version
                 control. {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Parsing. {\bf D.3.4}
                 Software, PROGRAMMING LANGUAGES, Processors, Translator
                 writing systems and compiler generators. {\bf E.1}
                 Data, DATA STRUCTURES, Trees.",
}

@Article{Apt:1998:AIL,
  author =       "Krzsztof R. Apt and Jacob Brunekreef and Vincent
                 Partington and Andrea Schaerf",
  title =        "{Alma-O}: An Imperative Language that Supports
                 Declarative Programming",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "5",
  pages =        "1014--1066",
  month =        sep,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-5/p1014-apt/",
  abstract =     "We describe here an implemented small programming
                 language, called Alma-O, that augments the expressive
                 power of imperative programming by a limited number of
                 features inspired by the logic programming paradigm.
                 These additions encourage declarative programming and
                 make it a more attractive vehicle for problems that
                 involve search. We illustrate the use of Alma-O by
                 presenting solutions to a number of classical problems,
                 including [alpha]-[beta] search, STRIPS planning,
                 knapsack, and Eight Queens. These solutions are
                 substantially simpler than their counterparts written
                 in the imperative or in the logic programming style and
                 can be used for different purposes without any
                 modification. We also discuss here the implementation
                 of Alma-O and an operational, executable, semantics of
                 a large subset of the language.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages",
  subject =      "{\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Nondeterministic languages**. {\bf
                 F.3.2} Theory of Computation, LOGICS AND MEANINGS OF
                 PROGRAMS, Semantics of Programming Languages,
                 Operational semantics. {\bf F.3.3} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Studies
                 of Program Constructs, Control primitives. {\bf I.2.8}
                 Computing Methodologies, ARTIFICIAL INTELLIGENCE,
                 Problem Solving, Control Methods, and Search,
                 Backtracking. {\bf I.5.5} Computing Methodologies,
                 PATTERN RECOGNITION, Implementation, Special
                 architectures.",
}

@Article{Giacobazzi:1998:LMR,
  author =       "Roberto Giacobazzi and Francesca Scozzari",
  title =        "A Logical Model for Relational Abstract Domains",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "5",
  pages =        "1067--1109",
  month =        sep,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 1 10:04:11 MST 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-5/p1067-giacobazzi/",
  abstract =     "In this article we introduce the notion of Heyting
                 completion in abstract interpretation. We prove that
                 Heyting completion provides a model for Cousot's
                 reduced cardinal power of abstract domains and that it
                 supplies a logical basis to specify relational domains
                 for program analysis and abstract interpretation. We
                 study the algebraic properties of Heyting completion in
                 relation with other well-known domain transformers,
                 like reduced product and disjunctive completion. This
                 provides a uniform algebraic setting where complex
                 abstract domains can be specified by simple logic
                 formulas, or as solutions of recursive abstract domain
                 equations, involving few basic operations for domain
                 construction, all characterized by a clean logical
                 interpretation. We apply our framework to characterize
                 directionality and condensing and in downward closed
                 analysis of (constraint) logic programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization. {\bf F.3.2} Theory of
                 Computation, LOGICS AND MEANINGS OF PROGRAMS, Semantics
                 of Programming Languages, Program analysis. {\bf F.4.1}
                 Theory of Computation, MATHEMATICAL LOGIC AND FORMAL
                 LANGUAGES, Mathematical Logic.",
}

@Article{Dhamdhere:1998:DCD,
  author =       "D. M. Dhamdhere and K. V. Sankaranarayanan",
  title =        "Dynamic currency determination in optimized programs",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1111--1130",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1111-dhamdhere/",
  abstract =     "Compiler optimizations pose many problems to
                 source-level debugging of an optimized program due to
                 reordering, insertion, and deletion of code. On such
                 problem is to determine whether the value of a variable
                 is {\em current\/} at a breakpoint---that is, whether
                 its actual value is the same as its expected value. We
                 use the notion of {\em dynamic currency\/} of a
                 variable in source-level debugging and propose the use
                 of a {\em minimal unrolled graph\/} to reduce the
                 run-time overhead of dynamic currency determination. We
                 prove that the minimal unrolled graph is an adequate
                 basis for performing bit-vector data flow analyses at a
                 breakpoint. This property is used to perform dynamic
                 currency determination. It is also shown to help in
                 recovery of a dynamically noncurrent variable.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance; theory",
  subject =      "{\bf D.2.5} Software, SOFTWARE ENGINEERING, Testing
                 and Debugging, Debugging aids. {\bf D.2.5} Software,
                 SOFTWARE ENGINEERING, Testing and Debugging, Symbolic
                 execution. {\bf D.2.5} Software, SOFTWARE ENGINEERING,
                 Testing and Debugging, Tracing. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Compilers. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Debuggers. {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Run-time environments.",
}

@Article{Hassen:1998:TDP,
  author =       "Saniya Ben Hassen and Henri E. Bal and Ceriel J. H.
                 Jacobs",
  title =        "A task- and data-parallel programming language based
                 on shared objects",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1131--1170",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1131-ben_hassen/",
  abstract =     "Many programming languages support either task
                 parallelism, but few languages provide a uniform
                 framework for writing applications that need both types
                 of parallelism or data parallelism. We present a
                 programming language and system that integrates task
                 and data parallelism using shared objects. Shared
                 objects may be stored on one processor or may be
                 replicated. Objects may also be partitioned and
                 distributed on several processors. Task parallelism is
                 achieved by forking processes remotely and have them
                 communicate and synchronize through objects. Data
                 parallelism is achieved by executing operations on
                 partitioned objects in parallel. Writing task-and
                 data-parallel applications with shared objects has
                 several advantages. Programmers use the objects as if
                 they were stored in a memory common to all processors.
                 On distributed-memory machines, if objects are remote,
                 replicated, or partitioned, the system takes care of
                 many low-level details such as data transfers and
                 consistency semantics. In this article, we show how to
                 write task-and data-parallel programs with our shared
                 object model. We also describe a portable
                 implementation of the model. To assess the performance
                 of the system, we wrote several applications that use
                 task and data parallelism and executed them on a
                 collection of Pentium Pros connected by Myrinet. The
                 performance of these applications is also discussed in
                 this article.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.1.3} Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming, Distributed programming. {\bf
                 D.1.3} Software, PROGRAMMING TECHNIQUES, Concurrent
                 Programming, Parallel programming. {\bf D.3.2}
                 Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Concurrent, distributed, and parallel
                 languages. {\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf D.3.4} Software,
                 PROGRAMMING LANGUAGES, Processors, Run-time
                 environments.",
}

@Article{Alur:1998:FF,
  author =       "Rajeev Alur and Thomas A. Henzinger",
  title =        "Finitary fairness",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1171--1194",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1171-alur/",
  abstract =     "Fairness is a mathematical abstraction: in a
                 multiprogramming environment, fairness abstracts the
                 details of admissible (``fair'') schedulers; in a
                 distributed environment, fairness abstracts the
                 relative speeds of processors. We argue that the
                 standard definition of fairness often is unnecessarily
                 weak and can be replaced by the stronger, yet still
                 abstract, notion of finitary fairness. While standard
                 weak fairness requires that no enabled transition is
                 postponed forever, finitary weak fairness requires that
                 for every computation of a system there is an unknown
                 bound $k$ such that no enabled transition is postponed
                 more than $k$ consecutive times. In general, the {\em
                 finitary restriction fin\/}($F$) of any given fairness
                 requirement $F$ is the union of all $ \omega $-regular
                 safety properties contained in $F$. The adequacy of the
                 proposed abstraction is shown in two ways. Suppose we
                 prove a program property under the assumption of
                 finitary fairness. In a multiprogramming environment,
                 the program then satisfies the property for all fair
                 finite-state schedulers. In a distributed environment,
                 the program then satisfies the property for all choices
                 of lower and upper bounds on the speeds (or timings) of
                 processors. The benefits of finitary fairness are
                 twofold. First, the proof rules for verifying liveness
                 properties of concurrent programs are simplified:
                 well-founded induction over the natural numbers is
                 adequate to prove termination under finitary fairness.
                 Second, the fundamental problem of consensus in a
                 faulty asynchronous distributed environment can be
                 solved assuming finitary fairness.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "theory; verification",
  subject =      "{\bf D.1.3} Software, PROGRAMMING TECHNIQUES,
                 Concurrent Programming. {\bf D.2.4} Software, SOFTWARE
                 ENGINEERING, Software/Program Verification. {\bf F.3.1}
                 Theory of Computation, LOGICS AND MEANINGS OF PROGRAMS,
                 Specifying and Verifying and Reasoning about
                 Programs.",
}

@Article{Yang:1998:STE,
  author =       "Tao Yang and Cong Fu",
  title =        "Space\slash time-efficient scheduling and execution of
                 parallel irregular computations",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1195--1222",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1195-yang/",
  abstract =     "In this article we investigate the trade-off between
                 time and space efficiency in scheduling and executing
                 parallel irregular computations on distributed-memory
                 machines. We employ acyclic task dependence graphs to
                 model irregular parallelism with mixed granularity, and
                 we use direct remote memory access to support fast
                 communication. We propose new scheduling techniques and
                 a run-time active memory management scheme to improve
                 memory utilization while retaining good time
                 efficiency, and we provide a theoretical analysis on
                 correctness and performance. This work is implemented
                 in the context of the RAPID system which uses an
                 inspector/executor approach to parallelize irregular
                 computations at run-time. We demonstrate the
                 effectiveness of the proposed techniques on several
                 irregular applications such as sparse matrix code and
                 the fast multipole method for particle simulation. Our
                 experimental results on Cray-T3E show that problems
                 large sizes can be solved under limited space capacity,
                 and that the loss of execution efficiency caused by the
                 extra memory management overhead is reasonable.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; design; experimentation; performance",
  subject =      "{\bf C.1.2} Computer Systems Organization, PROCESSOR
                 ARCHITECTURES, Multiple Data Stream Architectures
                 (Multiprocessors). {\bf D.1.3} Software, PROGRAMMING
                 TECHNIQUES, Concurrent Programming, Parallel
                 programming. {\bf D.3.4} Software, PROGRAMMING
                 LANGUAGES, Processors, Run-time environments. {\bf
                 G.2.2} Mathematics of Computing, DISCRETE MATHEMATICS,
                 Graph Theory, Graph algorithms.",
}

@Article{Kelly:1998:OCC,
  author =       "Andrew D. Kelly and Kim Marriott and Andrew MacDonald
                 and Peter J. Stuckey and Roland Yap",
  title =        "Optimizing compilation of {CLP({\cal R})}",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1223--1250",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1223-kelly/",
  abstract =     "Constraint Logic Programming (CLP) languages extend
                 logic programming by allowing the use of constraints
                 from different domains such as real numbers or Boolean
                 functions. They have proved to be ideal for expressing
                 problems that require interactive mathematical modeling
                 and complex combinatorial optimization problems.
                 However, CLP languages have mainly been considered as
                 research systems, useful for rapid prototyping, by not
                 really competitive with more conventional programming
                 languages where efficiency is a more important
                 consideration. One promising approach to improving the
                 performance of CLP systems is the use of powerful
                 program optimizations to reduce the cost of constraint
                 solving. We extend work in this area by describing a
                 new optimizing compiler for the CLP language CLP({\em R
                 \/}). The compiler implements six powerful
                 optimizations: reordering of constraints, removal of
                 redundant variables, and specialization of constraints
                 which cannot fail. Each program optimization is
                 designed to remove the overhead of constraint solving
                 when possible and keep the number of constraints in the
                 store as small as possible. We systematically evaluate
                 the effectiveness of each optimization in isolation and
                 in combination. Our empirical evaluation of the
                 compiler verifies that optimizing compilation can be
                 made efficient enough to allow compilation of
                 real-world programs and that it is worth performing
                 such compilation because it gives significant time and
                 space performance improvements.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "languages; performance",
  subject =      "{\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Constraint and logic languages. {\bf
                 D.3.4} Software, PROGRAMMING LANGUAGES, Processors,
                 Compilers.",
}

@Article{Palsberg:1998:EBF,
  author =       "Jens Palsberg",
  title =        "Equality-based flow analysis versus recursive types",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1251--1264",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1251-palsberg/",
  abstract =     "Equality-based control-flow analysis has been studied
                 by Henglein, Bondorf and J{\o}rgensen, DeFouw, Grove,
                 and Chambers, and others. It is faster than the
                 subset-based-0-CFA, but also more approximate. Heintze
                 asserted in 1995 that a program can be safety checked
                 with an equality-based control-flow analysis if and
                 only if it can be typed with recursive types. In this
                 article we falsify Heintze's assertion, and we present
                 a type system equivalent to equality-based control-flow
                 analysis. The new type system contains both recursive
                 types and an unusual notion of subtyping. We have $ s
                 \leq t $ if $s$ and $t$ unfold to the same regular
                 tree, and we have $ \bot \leq t \leq \top $ where $t$
                 is a function type. In particular, there is no
                 nontrivial subtyping between function types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; theory",
  subject =      "{\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language
                 Classifications, Applicative (functional) languages.
                 {\bf F.3.3} Theory of Computation, LOGICS AND MEANINGS
                 OF PROGRAMS, Studies of Program Constructs, Type
                 structure.",
}

@Article{Buchsbaum:1998:NSL,
  author =       "Adam L. Buchsbaum and Haim Kaplan and Anne Rogers and
                 Jeffery R. Westbrook",
  title =        "A new, simpler linear-time dominators algorithm",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1265--1296",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See corrigendum \cite{Buchsbaum:2005:CNS}.",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1265-buchsbaum/",
  abstract =     "We present a new linear-time algorithm to find the
                 immediate dominators of all vertices in a flowgraph.
                 Our algorithm is simpler than previous linear-time
                 algorithms: rather than employ complicated data
                 structures, we combine the use of microtrees and
                 memoization with new observations on a restricted class
                 of path compressions. We have implemented our
                 algorithm, and we report experimental results that show
                 that the constant factors are low. Compared to the
                 standard, slightly superlinear algorithm of Lengauer
                 and Tarjan, which has much less overhead, our algorithm
                 runs 10--20\% slower on real flowgraphs of reasonable
                 size and only a few percent slower on very large
                 flowgraphs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; languages; performance; theory",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Compilers. {\bf E.1} Data, DATA STRUCTURES,
                 Graphs and networks. {\bf F.2.2} Theory of Computation,
                 ANALYSIS OF ALGORITHMS AND PROBLEM COMPLEXITY,
                 Nonnumerical Algorithms and Problems, Computations on
                 discrete structures. {\bf G.2.2} Mathematics of
                 Computing, DISCRETE MATHEMATICS, Graph Theory, Graph
                 algorithms.",
}

@Article{Hailperin:1998:COC,
  author =       "Max Hailperin",
  title =        "Cost-optimal code motion",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1297--1322",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org:80/pubs/citations/journals/toplas/1998-20-6/p1297-hailperin/",
  abstract =     "We generalize Knoop et al.'s Lazy Code Motion (LCM)
                 algorithm for partial redundancy elimination so that
                 the generalized version also performs strength
                 reduction. Although Knoop et al. have themselves
                 extended LCM to strength reduction with their Lazy
                 Strength Reduction algorithm, our approach differs
                 substantially from theirs and results in a broader
                 class of candidate expressions, stronger safety
                 guarantees, and the elimination of the potential for
                 performance loss instead of gain. Also, our general
                 framework is not limited to traditional strength
                 reduction, but rather can also handle a wide variety of
                 optimizations in which data-flow information enables
                 the replacement of a computation with a less expensive
                 one. As a simple example, computations can be hoisted
                 to points where they are constant foldable. Another
                 example we sketch is the hoisting of polymorphic
                 operations to points where type analysis provides
                 leverage for optimization. Our general approach
                 consists of placing computations so as to minimize
                 their cost, rather than merely their number. So long as
                 the cost differences between flowgraph nodes obey a
                 certain natural constraint, a cost-optimal code motion
                 transformation that does not unnecessarily prolong the
                 lifetime of temporary variables can be found using
                 techniques completely analogous to LCM. Specifically,
                 the cost differences can be discovered using a wide
                 variety of forward data-flow analyses in a manner which
                 we describe.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "algorithms; performance",
  subject =      "{\bf D.3.4} Software, PROGRAMMING LANGUAGES,
                 Processors, Optimization",
}

@Article{Anonymous:1998:AI,
  author =       "Anonymous",
  title =        "1998 Author Index",
  journal =      j-TOPLAS,
  volume =       "20",
  number =       "6",
  pages =        "1323--1325",
  month =        nov,
  year =         "1998",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 21 14:24:56 MDT 1999",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bertsch:1999:FPT,
  author =       "Eberhard Bertsch and Mark-Jan Nederhof",
  title =        "On Failure of the Pruning Technique in {``Error Repair
                 in Shift-Reduce Parsers''}",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "1",
  pages =        "1--10",
  month =        jan,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{McKenzie:1995:ERS}.",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-1/p1-bertsch/",
  abstract =     "A previous article presented a technique to compute
                 the least-cost error repair by incrementally generating
                 configurations that result from inserting and deleting
                 tokens a syntactically incorrect input. An additional
                 mechanism to improve the run-time efficiency of this
                 algorithm by pruning some of the configurations was
                 discussed as well. In this communication we show that
                 the pruning mechanism may lead to suboptimal repairs or
                 may block {\em all\/} repairs. Certain grammatical
                 errors in a common construct of the Java programming
                 language also lead to the above kind of failure.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "error repair",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Parsing}",
}

@Article{Duggan:1999:DTD,
  author =       "Dominic Duggan",
  title =        "Dynamic Typing for Distributed Programming in
                 Polymorphic Languages",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "1",
  pages =        "11--45",
  month =        jan,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-1/p11-duggan/",
  abstract =     "While static typing is widely accepted as being
                 necessary for secure program execution, dynamic typing
                 is also viewed as being essential in some applications,
                 particularly for distributed programming environments.
                 {\em Dynamics\/} have been proposed as a language
                 construct for dynamic typing, based on experience with
                 languages such as CLU, Cedar/Mesa, and Modula-3.
                 However proposals for incorporating dynamic typing into
                 languages with parametric polymorphism have serious
                 shortcomings. A new approach is presented to extending
                 polymorphic languages with dynamic typing. At the heart
                 of the approach is the use of dynamic type dispatch,
                 where polymorphic functions may analyze the structure
                 of their type arguments. This approach solves several
                 open problems with the traditional approach to adding
                 dynamic typing to polymorphic languages. An explicitly
                 typed language XMLdyn is presented; this language uses
                 {\em refinement kinds\/} to ensure that dynamic type
                 dispatch does not fail at run-time. {\em Safe
                 dynamics\/} are a new form of dynamics that use
                 refinement kinds to statically check the use of
                 run-time dynamic typing. Run-time errors are isolated
                 to a separate construct for performing run-time type
                 checks",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dynamic typing; marshalling; parametric polmorphism;
                 static typing",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Semantics};
                 Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Data types and
                 structures}; Software --- Programming Techniques ---
                 Concurrent Programming (D.1.3)",
}

@Article{Liu:1999:SVF,
  author =       "Zhiming Liu and Mathai Joseph",
  title =        "Specification and Verification of Fault-Tolerance,
                 Timing, and Scheduling",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "1",
  pages =        "46--89",
  month =        jan,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-1/p46-liu/",
  abstract =     "Fault-tolerance and timing have often been considered
                 to be implementation issues of a program, quite
                 distinct from the functional safety and liveness
                 properties. Recent work has shown how these
                 non-functional and functional properties can be
                 verified in a similar way. However, the more practical
                 question of determining whether a real-time program
                 will meet its deadlines, i.e., showing that there is a
                 feasible schedule, is usually done using scheduling
                 theory, quite separately from the verification of other
                 properties of the program. This makes it hard to use
                 the results of scheduling analysis in the design, or
                 redesign, of fault-tolerant and real-time programs.
                 This article shows how fault-tolerance, timing, and
                 schedulability can be specified and verified using a
                 single notation and model. This allows a unified view
                 to be taken of the functional and nonfunctional
                 properties of programs and a simple transformational
                 method to be used to combine these properties. It also
                 permits results from scheduling theory to be
                 interpreted and used within a formal proof framework.
                 The notation and model are illustrated using a simple
                 example.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "fault-tolerance; real time; schedulability;
                 specification; transformation; verification",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4); Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3); Software
                 --- Operating Systems --- Organization and Design
                 (D.4.7): {\bf Real-time systems and embedded systems};
                 Software --- Operating Systems --- Reliability (D.4.5):
                 {\bf Fault-tolerance}; Software --- Operating Systems
                 --- Reliability (D.4.5); Software --- Operating Systems
                 --- Process Management (D.4.1): {\bf Scheduling};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Specifying and Verifying and Reasoning
                 about Programs (F.3.1)",
}

@Article{Stata:1999:TSJ,
  author =       "Raymie Stata and Martin Abadi",
  title =        "A Type System for {Java} Bytecode Subroutines",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "1",
  pages =        "90--137",
  month =        jan,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-1/p90-stata/",
  abstract =     "Java is typically compiled into an intermediate
                 language, JVML, that is interpreted by the Java Virtual
                 Machine. Because mobile JVML code is not always
                 trusted, a bytecode verifier enforces static
                 constraints that prevent various dynamic errors. Given
                 the importance of the bytecode verifier for security,
                 its current descriptions are inadequate. This article
                 proposes using typing rules to describe the bytecode
                 verifier because they are more precise than prose,
                 clearer than code, and easier to reason about than
                 either. JVML has a subroutine construct which is used
                 for the compilation of Java's try-finally statement.
                 Subroutines are a major source of complexity for the
                 bytecode verifier because they are not obviously
                 last-in/first-out and because they require a kind of
                 polymorphism. Focusing on subroutines, we isolate an
                 interesting, small subset of JVML. We give typing rules
                 for this subset and prove their correctness. Our type
                 system constitutes a sound basis for bytecode
                 verification and a rational reconstruction of a
                 delicate part of Sun's bytecode verifier.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "bytecode verification; Java; languages; security;
                 theory; verification",
  subject =      "Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Java}; Software ---
                 Programming Languages --- Formal Definitions and Theory
                 (D.3.1): {\bf Semantics}; Software --- Operating
                 Systems --- Security and Protection (D.4.6): {\bf
                 Invasive software}; 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
                 Program analysis}; Theory of Computation --- Logics and
                 Meanings of Programs --- Studies of Program Constructs
                 (F.3.3): {\bf Type structure}",
}

@Article{Narlikar:1999:SES,
  author =       "Girija J. Narlikar and Guy E. Blelloch",
  title =        "Space-Efficient Scheduling of Nested Parallelism",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "1",
  pages =        "138--173",
  month =        jan,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-1/p138-narlikar/",
  abstract =     "Many of today's high-level parallel languages support
                 dynamic, fine-grained parallelism. These languages
                 allow the user to expose all the parallelism in the
                 program, which is typically of a much higher degree
                 than the number of processors. Hence an efficient
                 scheduling algorithm is required to assign computations
                 to processors at runtime. Besides having low overheads
                 and good load balancing, it is important for the
                 scheduling algorithm to minimize the space usage of the
                 parallel program. This article presents an on-line
                 scheduling algorithm that is provably space efficient
                 and time efficient for nested-parallel languages. For a
                 computation with depth $D$ and serial space requirement
                 $ S_1$, the algorithm generates a schedule that
                 requires at most $ S_1 + O(K \cdot D \cdot p)$ space
                 (including scheduler space) on $p$ processors. Here,
                 $K$ is a user-adjustable runtime parameter specifying
                 the net amount of memory that a thread may allocate
                 before it is preempted by the scheduler. Adjusting the
                 value of $K$ provides a trade-off between the running
                 time and the memory requirement of a parallel
                 computation. To allow the scheduler to scale with the
                 number of processors we also parallelize the scheduler
                 and analyze the space and time bounds of the
                 computation to include scheduling costs. In addition to
                 showing that the scheduling algorithm is space and time
                 efficient in theory, we demonstrate that it is
                 effective in practice. We have implemented a runtime
                 system that uses our algorithm to schedule lightweight
                 parallel threads. The results of executing parallel
                 programs on this system show that our scheduling
                 algorithm significantly reduces memory usage compared
                 to previous techniques, without compromising
                 performance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dynamic scheduling; multithreading; nested
                 parallelism; parallel language implementation; space
                 efficiency",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3): {\bf Parallel programming};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Run-time environments}; Theory of
                 Computation --- Analysis of Algorithms and Problem
                 Complexity --- General (F.2.0)",
}

@Article{Ramalingam:1999:ILA,
  author =       "G. Ramalingam",
  title =        "Identifying loops in almost linear time",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "175--188",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p175-ramalingam/",
  abstract =     "Loop identification is an essential step in performing
                 various loop optimizations and transformations. The
                 classical algorithm for identifying loops is Tarjan's
                 interval-finding algorithm, which is restricted to
                 reducible graphs. More recently, several people have
                 proposed extensions to Tarjan's algorithm to deal with
                 irreducible graphs. Havlak presents one such extension,
                 which constructs a loop-nesting forest for an arbitrary
                 flow graph. We show that the running time of this
                 algorithm is quadratic in the worst-case, and not
                 almost linear as claimed. We then show how to modify
                 the algorithm to make it run in almost linear time. We
                 next consider the quadratic algorithm presented by
                 Sreedhar et al. which constructs a loop-nesting forest
                 different from the one constructed by Havlak algorithm.
                 We show that this algorithm too can be adapted to run
                 in almost linear time. We finally consider an algorithm
                 due to Steensgaard, which constructs yet another
                 loop-nesting forest. We show how this algorithm can be
                 made more efficient by borrowing ideas from the other
                 algorithms discussed earlier.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "irreducible flowgraphs; loops",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Optimization}; Software --- Programming
                 Languages --- Processors (D.3.4); Data --- Data
                 Structures (E.1): {\bf Graphs and networks}; Data ---
                 Data Structures (E.1); Mathematics of Computing ---
                 Discrete Mathematics --- Graph Theory (G.2.2): {\bf
                 Graph algorithms}; Mathematics of Computing ---
                 Discrete Mathematics --- Graph Theory (G.2.2)",
}

@Article{Bueno:1999:EAI,
  author =       "Francisco Bueno and Mar{\'\i}a Garc{\'\i}a de la Banda
                 and Manuel Hermenegildo",
  title =        "Effectiveness of abstract interpretation in automatic
                 parallelization: a case study in logic programming",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "189--239",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p189-bueno/",
  abstract =     "We report on a detailed study of the application and
                 effectiveness of program analysis based on abstract
                 interpretation of automatic program parallelization. We
                 study the case of parallelizing logic programs using
                 the notion of strict independence. We first propose and
                 prove correct a methodology for the application in the
                 parallelization task of the information inferred by
                 abstract interpretation, using a parametric domain. The
                 methodology is generic in the sense of allowing the use
                 of different analysis domains. A number of well-known
                 approximation domains are then studied and the
                 transformation into the parametric domain defined. The
                 transformation directly illustrates the relevance and
                 applicability of each abstract domain for the
                 application. Both local and global analyzers are then
                 built using these domains and embedded in a complete
                 parallelizing compiler. Then, the performance of the
                 domains in this context is assessed through a number of
                 experiments. A comparatively wide range of aspects is
                 studied, from the resources needed by the analyzers in
                 terms of time and memory to the actual benefits
                 obtained from the information inferred. Such benefits
                 are evaluated both in terms of the characteristics of
                 the parallelized code and of the actual speedups
                 obtained from it. The results show that data flow
                 analysis plays an important role in achieving efficient
                 parallelizations, and that the cost of such analysis
                 con be reasonable even for quite sophisticated abstract
                 domains. Furthermore, the results also offer
                 significant insight into the characteristics of the
                 domains, the demands of the application, and the
                 trade-offs involved.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; automatic parallelization;
                 data flow analysis; logic programming; parallelism",
  subject =      "Software --- Programming Techniques --- Automatic
                 Programming (D.1.2); Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3): {\bf
                 Parallel programming}; Software --- Programming
                 Techniques --- Logic Programming (D.1.6); Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; 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); Computing
                 Methodologies --- Artificial Intelligence --- Automatic
                 Programming (I.2.2): {\bf Automatic analysis of
                 algorithms}; Computing Methodologies --- Artificial
                 Intelligence --- Automatic Programming (I.2.2);
                 Computing Methodologies --- Artificial Intelligence ---
                 Automatic Programming (I.2.2): {\bf Program
                 transformation}",
}

@Article{Greiner:1999:PTE,
  author =       "John Greiner and Guy E. Blelloch",
  title =        "A provably time-efficient parallel implementation of
                 full speculation",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "240--285",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p240-greiner/",
  abstract =     "Speculative evaluation, including leniency and
                 futures, is often used to produce high degrees of
                 parallelism. Understanding the performance
                 characteristics of such evaluation, however, requires
                 having a detailed understanding of the implementation.
                 For example, the particular implementation technique
                 used to suspend and reactivate threads can have an
                 asymptotic effect on performance. With the goal of
                 giving the users some understanding of performance
                 without requiring them to understand the
                 implementation, we present a provable implementation
                 bound for a language based on speculative evaluation.
                 The idea is (1) to supply the users with a semantics
                 for a language that defines abstract costs for
                 measuring or analyzing the performance of computations,
                 (2) to supply the users with a mapping of these costs
                 onto runtimes on various machine models, and (3) to
                 describe an implementation strategy of the language and
                 prove that it meets these mappings. For this purpose we
                 consider a simple language based on speculative
                 evaluation. For every computation, the semantics of the
                 language returns a directed acyclic graph (DAG) in
                 which each node represents a unit of computation, and
                 each edge represents a dependence. We then describe an
                 implementation strategy of the language and show that
                 any computation with $w$ work (the number of nodes in
                 the DAG) and $d$ depth (the length of the longest path
                 in the DAG) will run on a $p$-processor PRAM in $ O(w /
                 p + d \log p)$ time. The bounds are work efficient
                 (within a constant factor of linear speedup) when there
                 is sufficient parallelism, $ w / d p \log p$. These are
                 the first time bounds we know of for languages with
                 speculative evaluation. The main challenge is in
                 parallelizing the necessary queuing operations on
                 suspended threads.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Performance; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract machines; parallel languages; profiling
                 semantics; speculation; threads",
  subject =      "Software --- Software Engineering --- Metrics (D.2.8);
                 Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Data-flow languages};
                 Software --- Programming Languages --- Language
                 Classifications (D.3.2); Theory of Computation ---
                 Computation by Abstract Devices --- Modes of
                 Computation (F.1.2): {\bf Parallelism and concurrency};
                 Theory of Computation --- Computation by Abstract
                 Devices --- Modes of Computation (F.1.2); Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1)",
}

@Article{DeRose:1999:TTM,
  author =       "Luiz {De Rose} and David Padua",
  title =        "Techniques for the translation of {MATLAB} programs
                 into {Fortran 90}",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "286--323",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p286-de_rose/",
  abstract =     "This article describes the main techniques developed
                 for FALCON's MATLAB-to-Fortran 90 compiler. FALCON is a
                 programming environment for the development of
                 high-performance scientific programs. It combines
                 static and dynamic inference methods to translate
                 MATLAB programs into Fortran 90. The static inference
                 is supported with advanced value propagation techniques
                 and symbolic algorithms for subscript analysis.
                 Experiments show that FALCON's MATLAB translator can
                 generate code that performs more than 1000 times faster
                 than the interpreted version of MATLAB and
                 substantially faster than commercially available MATLAB
                 compilers on one processor of an SGI Power Challenge.
                 Furthermore, in most cases we have tested, the
                 compiler-generated code is as fast as corresponding
                 hand-written programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Java; Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "array language compilation; inference; MATLAB",
  subject =      "Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Very high-level
                 languages}; Software --- Programming Languages ---
                 Language Classifications (D.3.2); Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Software --- Programming Languages ---
                 Processors (D.3.4); Computing Methodologies ---
                 Symbolic and Algebraic Manipulation --- Algorithms
                 (I.1.2)",
}

@Article{Poletto:1999:CTL,
  author =       "Massimiliano Poletto and Wilson C. Hsieh and Dawson R.
                 Engler and M. Frans Kaashoek",
  title =        "{'C} and {\tt tcc}: a language and compiler for
                 dynamic code generation",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "324--369",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p324-poletto/",
  abstract =     "Dynamic code generation allows programmers to use
                 run-time information in order to achieve performance
                 and expressiveness superior to those of static code.
                 The 'C ({\em Tick C\/}) language is a superset of ANSI
                 C that supports efficient and high-level use of dynamic
                 code generation. 'C provides dynamic code generation at
                 the level of C expressions and statements and supports
                 the composition of dynamic code at run time. These
                 features enable programmers to add dynamic code
                 generation to existing C code incrementally and to
                 write important applications (such as ``just-in-time''
                 compilers) easily. The article presents many examples
                 of how 'C can be used to solve practical problems. The
                 {\tt tcc} compiler is an efficient, portable, and
                 freely available implementation of 'C. {\tt tcc} allows
                 programmers to trade dynamic compilation speed for
                 dynamic code quality: in some applications, it is most
                 important to generate code quickly, while in others
                 code quality matters more than compilation speed. The
                 overhead of dynamic compilation is on the order of 100
                 to 600 cycles per generated instruction, depending on
                 the level of dynamic optimization. Measurements show
                 that the use of dynamic code generation can improve
                 performance by almost an order of magnitude; two- to
                 four-fold speedups are common. In most cases, the
                 overhead of dynamic compilation is recovered in under
                 100 uses of the dynamic code; sometimes it can be
                 recovered within one use.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "ANSI C; compilers; dynamic code generation; dynamic
                 code optimization",
  subject =      "Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Specialized application
                 languages}; Software --- Programming Languages ---
                 Language Classifications (D.3.2); Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3); Software --- Programming Languages
                 --- Processors (D.3.4): {\bf Code generation}; Software
                 --- Programming Languages --- Processors (D.3.4);
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Run-time
                 environments}",
}

@Article{Flanagan:1999:CSB,
  author =       "Cormac Flanagan and Matthias Felleisen",
  title =        "Componential set-based analysis",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "2",
  pages =        "370--416",
  month =        mar,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p370-flanagan/",
  abstract =     "Set-based analysis (SBA) produces good predictions
                 about the behavior of functional and object-oriented
                 programs. The analysis proceeds by inferring {\em
                 constraints\/} that characterize the data flow
                 relationships of the analyzed program. Experiences with
                 MrSpidey, a static debugger based on SBA, indicate that
                 SBA can adequately deal with programs of up to a couple
                 of thousand lines of code. SBA fails, however, to cope
                 with larger programs because it generates systems of
                 constraints that are at least linear, and possibility
                 quadratic, in the size of the analyzed program. This
                 article presents theoretical and practical results
                 concerning methods for reducing the size of constraint
                 systems. The theoretical results include of
                 proof-theoretic characterization of the {\em observable
                 behavior\/} of constraint systems for program
                 components, and a complete algorithm for deciding the
                 observable equivalence of constraint systems. In the
                 course of this development we establish a close
                 connection between the observable equivalence of
                 constraint systems and the equivalence of regular-tree
                 grammars. We then exploit this connection to adapt a
                 variety of algorithms for simplifying grammars to the
                 problem of simplifying constraint systems. Based on the
                 resulting algorithms, we have developed {\em
                 componential set-based analysis}, a modular and
                 polymorphic variant of SBA. Experimental results verify
                 the effectiveness of the simplification algorithms and
                 the componential analysis. The simplified constraint
                 systems are typically an order of magnitude smaller
                 than the original systems. These reductions in size
                 produce significant gains in the speed of the
                 analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "constraint-based analysis; program analysis; scheme;
                 soft typing; static debugging",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Debugging aids}; Software ---
                 Software Engineering --- Testing and Debugging (D.2.5);
                 Software --- Software Engineering --- Programming
                 Environments (D.2.6); Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Debuggers};
                 Software --- Programming Languages --- Processors
                 (D.3.4); Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}; 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 Mechanical verification};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Studies of Program Constructs (F.3.3);
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Studies of Program Constructs (F.3.3):
                 {\bf Type structure}; Software --- Software Engineering
                 --- Testing and Debugging (D.2.5): {\bf Symbolic
                 execution}",
}

@Article{Butler:1999:RAG,
  author =       "Michael Butler and Pieter Hartel",
  title =        "Reasoning about {Grover}'s quantum search algorithm
                 using probabilistic {\em wp}",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "417--429",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p417-butler/p417-butler.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p417-butler/",
  abstract =     "Grover's search algorithm is designed to be executed
                 on a quantum-mechanical computer. In this article, the
                 probabilistic {\em wp\/}-calculus is used to model and
                 reason about Grover's algorithm. It is demonstrated
                 that the calculus provides a rigorous programming
                 notation for modeling this and other quantum algorithms
                 and that it also provides a systematic framework of
                 analyzing such algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "quantum computation, quantum mechanics",
  subject =      "Mathematics of Computing --- Probability and
                 Statistics (G.3); Theory of Computation --- Analysis of
                 Algorithms and Problem Complexity --- General (F.2.0);
                 Theory of Computation --- Logics and Meanings of
                 Programs --- General (F.3.0)",
}

@Article{Gudjonsson:1999:CTM,
  author =       "Gudj{\'o}n Gudj{\'o}nsson and William H. Winsborough",
  title =        "Compile-time memory reuse in logic programming
                 languages through update in place",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "430--501",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p430-gudjonsson/p430-gudjonsson.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p430-gudjonsson/",
  abstract =     "Standard implementation techniques for
                 single-assignment languages modify a data structure
                 without destroying the original, which may subsequently
                 be accessed. Instead a variant structure is created by
                 using newly allocated cells to represent the changed
                 portion and to replace any cell that references a newly
                 allocated cell. The rest of the original structure is
                 shared by the variant. The effort required to leave the
                 original uncorrupted is unnecessary when the program
                 will never reference the original again. This effort
                 includes allocating and initializing new cells, as well
                 as garbage collecting replaced cells. This article
                 specifies a transformation system that introduces
                 update-in-place operations, making Prolog programs
                 update recursive data structures much as an imperative
                 program would. The article introduces the notion of a
                 reuse map, which formalizes reallocation decisions.
                 Because optimal memory reuse is intractable, a
                 heuristic method is presented that performs well in
                 practice. Small Prolog programs that manipulate
                 recursive data structures have their speed increased up
                 to about five times (naive recurse), not counting any
                 speedup obtained by avoiding garbage collection.
                 Quicksort is about three times as fast, merge-sort
                 about one and a half, matrix transposition about twice,
                 and Gaussian elimination is about 1.2 times as fast.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Experimentation; Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compile-time garbage collection; local reuse; Prolog;
                 reuse map; update in place",
  subject =      "Software --- Programming Techniques --- Applicative
                 (Functional) Programming (D.1.1); Software ---
                 Programming Techniques --- Logic Programming (D.1.6);
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization};
                 Software --- Operating Systems --- Storage Management
                 (D.4.2): {\bf Allocation/deallocation strategies};
                 Computing Methodologies --- Artificial Intelligence ---
                 Automatic Programming (I.2.2): {\bf Program
                 transformation}",
}

@Article{Lamport:1999:SYS,
  author =       "Leslie Lamport and Lawrence C. Paulson",
  title =        "Should your specification language be typed",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "502--526",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p502-lamport/p502-lamport.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p502-lamport/",
  abstract =     "Most specification languages have a type system. Type
                 systems are hard to get right, and getting them wrong
                 can lead to inconsistencies. Set theory can serve as
                 the basis for a specification language without types.
                 This possibility, which has been widely overlooked,
                 offers many advantages. Untyped set theory is simple
                 and is more flexible than any simple typed formalism.
                 Polymorphism, overloading, and subtyping can make a
                 type system more powerful, but at the cost of increased
                 complexity, and such refinements can never attain the
                 flexibility of having no types at all. Typed formalisms
                 have advantages, too, stemming from the power of
                 mechanical type checking. While types serve little
                 purpose in hand proofs, they do help with mechanized
                 proofs. In the absence of verification, type checking
                 can catch errors in specifications. It may be possible
                 to have the best of both worlds by adding typing
                 annotations to an untyped specification
                 language.\par

                 We consider only specification languages, not
                 programming languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "set theory; specification; types",
  subject =      "Software --- Software Engineering ---
                 Requirements/Specifications (D.2.1); 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
                 Specification techniques}",
}

@Article{Morrisett:1999:SFT,
  author =       "Greg Morrisett and David Walker and Karl Crary and
                 Neal Glew",
  title =        "From {System F} to typed assembly language",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "527--568",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p527-morrisett/p527-morrisett.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p527-morrisett/",
  abstract =     "We motivate the design of typed assembly language
                 (TAL) and present a type-preserving translation from
                 System F to TAL. The typed assembly language we present
                 is based on a conventional RISC assembly language, but
                 its static type system provides support for enforcing
                 high-level language abstractions, such as closures,
                 tuples, and user-defined abstract data types. The type
                 system ensures that well-typed programs cannot violate
                 these abstractions. In addition, the typing constructs
                 admit many low-level compiler optimizations. Our
                 translation to TAL is specified as a sequence of
                 type-preserving transformations, including CPS and
                 closure conversion phases; type-correct source programs
                 are mapped to type-correct assembly language. A key
                 contribution is an approach to polymorphic closure
                 conversion that is considerably simpler than previous
                 work. The compiler and typed assembly language provide
                 a fully automatic way to produce certified code,
                 suitable for use in systems where untrusted and
                 potentially malicious code must be checked for safety
                 before execution.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Security; Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "certified code; closure conversion; secure extensible
                 systems; type-directed compilation; typed assembly
                 language; typed intermediate languages",
  subject =      "Software --- Software Engineering --- Software
                 Architectures (D.2.11): {\bf Languages (e.g.,
                 description, interconnection, definition)}; Software
                 --- Programming Languages --- Formal Definitions and
                 Theory (D.3.1): {\bf Semantics}; Software ---
                 Programming Languages --- Formal Definitions and Theory
                 (D.3.1): {\bf Syntax}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Macro and assembly languages}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Compilers};
                 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 ---
                 Studies of Program Constructs (F.3.3): {\bf Type
                 structure}",
}

@Article{Haridi:1999:ELV,
  author =       "Seif Haridi and Peter {Van Roy} and Per Brand and
                 Michael Mehl and Ralf Scheidhauer and Gert Smolka",
  title =        "Efficient logic variables for distributed computing",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "569--626",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p569-haridi/p569-haridi.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p569-haridi/",
  abstract =     "We define a practical algorithm for distributed
                 rational tree unification and prove its correctness in
                 both the off-line and on-line cases. We derive the
                 distributed algorithm from a centralized one, showing
                 clearly the trade-offs between local and distributed
                 execution. The algorithm is used to realize logic
                 variables in the Mozart Programming System, which
                 implements the Oz language (see
                 http://www/mozart-oz.org). Oz appears to the programmer
                 as a concurrent object-oriented language with dataflow
                 synchronization. Logic variables implement the dataflow
                 behavior. We show that logic variables can easily be
                 added to the more restricted models of Java and ML,
                 thus providing an alternative way to do concurrent
                 programming in these languages. We present common
                 distributed programming idioms in a network-transparent
                 way using logic variables. We show that in common cases
                 the algorithm maintains the same message latency as
                 explicit message passing. In addition, it is able to
                 handle uncommon cases that arise from the properties of
                 latency tolerance and third-party independence. This is
                 evidence that using logic variables in distributed
                 computing is beneficial at both the system and language
                 levels. At the system level, they improve latency
                 tolerance and third-party independence. At the language
                 level, they help make network-transparent distribution
                 practical.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "distributed algorithms; Mozart; Oz",
  subject =      "Software --- Programming Techniques --- Concurrent
                 Programming (D.1.3): {\bf Distributed programming};
                 Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Concurrent, distributed,
                 and parallel languages}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Constraint and logic languages}; Software ---
                 Programming Languages --- Language Classifications
                 (D.3.2): {\bf Data-flow languages}; Software ---
                 Programming Languages --- Language Classifications
                 (D.3.2): {\bf Multiparadigm languages}; Software ---
                 Programming Languages --- Language Constructs and
                 Features (D.3.3): {\bf Concurrent programming
                 structures}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf
                 Constraints}; Theory of Computation --- Computation by
                 Abstract Devices --- Modes of Computation (F.1.2): {\bf
                 Online computation}",
}

@Article{Kennedy:1999:PRE,
  author =       "Robert Kennedy and Sun Chan and Shin-Ming Liu and
                 Raymond Lo and Peng Tu and Fred Chow",
  title =        "Partial redundancy elimination in {SSA} form",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "627--676",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p627-kennedy/p627-kennedy.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p627-kennedy/",
  abstract =     "The SSAPRE algorithm for performing partial redundancy
                 elimination based entirely on SSA form is presented.
                 The algorithm is formulated based on a new conceptual
                 framework, the factored redundancy graph, for analyzing
                 redundancy, and represents the first sparse approach to
                 the classical problem and on methods for its solution.
                 With the algorithm description, theorems and their
                 proofs are given showing that the algorithm produces
                 the best possible code by the criteria of computational
                 optimality and lifetime optimality of the introduced
                 temporaries. In addition to the base algorithm, a
                 practical implementation of SSAPRE that exhibits
                 additional compile-time efficiencies is described. In
                 closing, measurement statistics are provided that
                 characterize the instances of the partial redundancy
                 problem from a set of benchmark programs and compare
                 optimization time spent by an implementation of SSAPRE
                 against a classical partial redundancy elimination
                 implementation. The data lend insight into the nature
                 of partial redundancy elimination and demonstrate the
                 expediency of this new approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Measurement; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code motion; common subexpressions; data flow
                 analysis; partial redundancy; static single assignment
                 form",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Control
                 structures}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf Data
                 types and structures}; Software --- Programming
                 Languages --- Language Constructs and Features (D.3.3):
                 {\bf Procedures, functions, and subroutines}; 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};
                 Computing Methodologies --- Artificial Intelligence ---
                 Automatic Programming (I.2.2): {\bf Program
                 transformation}",
}

@Article{Morris:1999:SF,
  author =       "J. M. Morris and A. Bunkenburg",
  title =        "Specificational functions",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "3",
  pages =        "677--701",
  month =        may,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-3/p677-morris/p677-morris.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-3/p677-morris/",
  abstract =     "Mathematics supplies us with various operators for
                 creating functions from relations, sets, known
                 functions, and so on. Function inversion is a simple
                 example. These operations are useful in specifying
                 programs. However, many of them have strong constraints
                 on their arguments to ensure that the result is indeed
                 a function. For example, only functions that are
                 bijective may be inverted. This is a serious impediment
                 to their use in specifications, because at best it
                 limits the specifier's expressive power, and at worst
                 it imposes strong proof obligations on the programmer.
                 We propose to loosen the definition of functions so
                 that the constraints on operations such as inversion
                 can be greatly relaxed. The specificational functions
                 that emerge generalize traditional functions in that
                 their application to some arguments may yield no good
                 outcome, while for other arguments their application
                 may yield any of several outcomes unpredictably. While
                 these functions are not in general algorithmic, they
                 can serve as specifications of traditional functions as
                 embodied in programming languages. The idea of
                 specificational functions is not new, but accommodating
                 them in all their generality without falling foul of a
                 myriad of anomalies has proved elusive. We investigate
                 the technical problems that have hindered their use,
                 and propose solutions. In particular, we develop a
                 formal axiomatization for reasoning about
                 specificational functions, and we prove its consistency
                 by constructing a model.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Design; Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "expression; function; logic; nondeterminacy;
                 refinement calculus",
  subject =      "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 --- Mathematical Logic and Formal
                 Languages --- Mathematical Logic (F.4.1): {\bf Lambda
                 calculus and related systems}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Correctness proofs}; Software --- Software
                 Engineering --- Software/Program Verification (D.2.4):
                 {\bf Formal methods}",
}

@Article{Ghosh:1999:CME,
  author =       "Somnath Ghosh and Margaret Martonosi and Sharad
                 Malik",
  title =        "Cache miss equations: a compiler framework for
                 analyzing and tuning memory behavior",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "4",
  pages =        "703--746",
  month =        jul,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-4/p703-ghosh/p703-ghosh.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-4/p703-ghosh/",
  abstract =     "With the ever-widening performance gap between
                 processors and main memory, cache memory, which is used
                 to bridge this gap, is becoming more and more
                 significant. Caches work well for programs that exhibit
                 sufficient locality. Other programs, however, have
                 reference patterns that fail to exploit the cache,
                 thereby suffering heavily from high memory latency. In
                 order to get high cache efficiency and achieve good
                 program performance, efficient memory accessing
                 behavior is necessary. In fact, for many programs,
                 program transformations or source-code changes can
                 radically alter memory access patterns, significantly
                 improving cache performance. Both hand-tuning and
                 compiler optimization techniques are often used to
                 transform codes to improve cache utilization.
                 Unfortunately, cache conflicts are difficult to predict
                 and estimate, precluding effective transformations.
                 Hence, effective transformations require detailed
                 knowledge about the frequency and causes of cache
                 misses in the code. This article describes methods for
                 generating and solving Cache Miss Equations (CMEs) that
                 give a detailed representation of cache behavior,
                 including conflict misses, in loop-oriented scientific
                 code. Implemented within the SUIF compiler framework,
                 our approach extends traditional compiler reuse
                 analysis to generate linear Diophantine equations that
                 summarize each loop's memory behavior. While solving
                 these equations is in general difficult, we show that
                 is also unnecessary, as mathematical techniques for
                 manipulating Diophantine equations allow us to
                 relatively easily compute and/or reduce the number of
                 possible solutions, where each solution corresponds to
                 a potential cache miss. The mathematical precision of
                 CMEs allows us to find true optimal solutions for
                 transformations such as blocking or padding. The
                 generality of CMEs also allows us to reason about
                 interactions between transformations applied in
                 concert. The article also gives examples of their use
                 to determine array padding and offset amounts that
                 minimize cache misses, and to determine optimal
                 blocking factors for tiled code. Overall, these
                 equations represent an analysis framework that offers
                 the generality and precision needed for detailed
                 compiler optimizations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Experimentation; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "cache memories; compilation; optimization; program
                 transformation",
  subject =      "Computer Systems Organization --- Processor
                 Architectures --- General (C.1.0); Computer Systems
                 Organization --- Performance of Systems (C.4): {\bf
                 Measurement techniques}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Compilers};
                 Computer Systems Organization --- Performance of
                 Systems (C.4): {\bf Modeling techniques}; Hardware ---
                 Memory Structures --- Design Styles (B.3.2): {\bf Cache
                 memories}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}",
}

@Article{Bultan:1999:MCC,
  author =       "Tevfik Bultan and Richard Gerber and William Pugh",
  title =        "Model-checking concurrent systems with unbounded
                 integer variables: symbolic representations,
                 approximations, and experimental results",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "4",
  pages =        "747--789",
  month =        jul,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-4/p747-bultan/p747-bultan.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-4/p747-bultan/",
  abstract =     "Model checking is a powerful technique for analyzing
                 large, finite-state systems. In an infinite state
                 system, however, many basic properties are undecidable.
                 In this article, we present a new symbolic model
                 checker which conservatively evaluates safety and
                 liveness properties on programs with unbounded integer
                 variables. We use Presburger formulas to symbolically
                 encode a program's transition system, as well as its
                 model-checking computations. All fixpoint calculations
                 are executed symbolically, and their convergence is
                 guaranteed by using approximation techniques. We
                 demonstrate the promise of this technology on some
                 well-known infinite-state concurrency problems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; 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): {\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}",
}

@Article{Blume:1999:DAS,
  author =       "Matthias Blume",
  title =        "Dependency analysis for {Standard ML}",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "4",
  pages =        "790--812",
  month =        jul,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-4/p790-blume/p790-blume.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-4/p790-blume/",
  abstract =     "Automatic dependency analysis is a useful addition to
                 a system like CM, our compilation manager for Standard
                 ML of New Jersey. It relieves the programmer from the
                 tedious and error-prone task of having to specify
                 compilation dependencies by hand and thereby makes its
                 usage more user friendly. But dependency analysis is
                 not easy, as the general problem for Standard ML is
                 NP-complete. Therefore, CM has to impose certain
                 restrictions on the programming language to recover
                 tractability. We prove the NP-completeness result,
                 discuss the restrictions on ML that are used by CM, and
                 provide the resulting analysis algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compilation management; dependency analysis;
                 NP-completeness",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Modules,
                 packages}; Theory of Computation --- Analysis of
                 Algorithms and Problem Complexity --- Nonnumerical
                 Algorithms and Problems (F.2.2)",
}

@Article{Blume:1999:HM,
  author =       "Matthias Blume and Andrew W. Appel",
  title =        "Hierarchical modularity",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "4",
  pages =        "813--847",
  month =        jul,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-4/p813-blume/p813-blume.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-4/p813-blume/",
  abstract =     "To cope with the complexity of very large systems, it
                 is not sufficient to divide them into simple pieces
                 because the pieces themselves will either be too
                 numerous or too large. A hierarchical modular structure
                 is the natural solution. In this article we explain how
                 that approach can be applied to software. Our
                 compilation manager provides a language for specifying
                 where individual modules fit into a hierarchy and how
                 they are related semantically. We pay particular
                 attention to the structure of the global name space of
                 program identifiers that are used for module linkage
                 because any potential for name clashes between
                 otherwise unrelated parts of a program can negatively
                 affect modularity. We discuss the theoretical issues in
                 building software hierarchically, and we describe our
                 implementation of CM, the compilation manager for
                 Standard ML of New Jersey.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compilation management; linking; modularity; modules;
                 name visibility; program structure",
  subject =      "Software --- Software Engineering --- Design Tools and
                 Techniques (D.2.2): {\bf Modules and interfaces};
                 Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Modules,
                 packages}",
}

@Article{Hind:1999:IPA,
  author =       "Michael Hind and Michael Burke and Paul Carini and
                 Jong-Deok Choi",
  title =        "Interprocedural pointer alias analysis",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "4",
  pages =        "848--894",
  month =        jul,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-4/p848-hind/p848-hind.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-4/p848-hind/",
  abstract =     "We present practical approximation methods for
                 computing and representing interprocedural aliases for
                 a program written in a language that includes pointers,
                 reference parameters, and recursion. We present the
                 following contributions: (1) a framework for
                 interprocedural pointer alias analysis that handles
                 function pointers by constructing the program call
                 graph while alias analysis is being performed; (2) a
                 {\em flow-sensitive\/} interprocedural pointer alias
                 analysis algorithm; (3) a {\em flow-insensitive\/}
                 interprocedural pointer alias analysis algorithm; (4) a
                 {\em flow-insensitive\/} interprocedural pointer alias
                 analysis algorithm that incorporates {\em kill\/}
                 information to improve precision; (5) empirical
                 measurements of the efficiency and precision of the
                 three interprocedural alias analysis algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "interprocedural analysis; pointer aliasing; program
                 analysis",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Optimization}",
}

@Article{Poletto:1999:LSR,
  author =       "Massimiliano Poletto and Vivek Sarkar",
  title =        "Linear scan register allocation",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "5",
  pages =        "895--913",
  month =        sep,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-5/p895-poletto/p895-poletto.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-5/p895-poletto/",
  abstract =     "We describe a new algorithm for fast global register
                 allocation called {\em linear scan}. This algorithm is
                 not based on graph coloring, but allocates registers to
                 variables in a single linear-time scan of the
                 variables' live ranges. The linear scan algorithm is
                 considerably faster than algorithms based on graph
                 coloring, is simple to implement, and results in code
                 that is almost as efficient as that obtained using more
                 complex and time-consuming register allocators based on
                 graph coloring. The algorithm is of interest in
                 applications where compile time is a concern, such as
                 dynamic compilation systems, `just-in-time' compilers,
                 and interactive development environments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code optimization; compilers; register allocation",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Code
                 generation}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}",
}

@Article{Kobayashi:1999:LPC,
  author =       "Naoki Kobayashi and Benjamin C. Pierce and David N.
                 Turner",
  title =        "Linearity and the {Pi-Calculus}",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "5",
  pages =        "914--947",
  month =        sep,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-5/p914-kobayashi/p914-kobayashi.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-5/p914-kobayashi/",
  abstract =     "The economy and flexibility of the pi-calculus make it
                 an attractive object of theoretical study and a clean
                 basis for concurrent language design and
                 implementation. However, such generality has a cost:
                 encoding higher-level features like functional
                 computation in pi-calculus throws away potentially
                 useful information. We show how a linear type system
                 can be used to recover important static information
                 about a process's behavior. In particular, we can
                 guarantee that two processes communicating over a
                 linear channel cannot interfere with other
                 communicating processes. After developing standard
                 results such as soundness of typing, we focus on
                 equivalences, adapting the standard notion of barbed
                 bisimulation to the linear setting and showing how
                 reductions on linear channels induce a useful ``partial
                 confluence'' of process behaviors. For an extended
                 example of the theory, we prove the validity of a
                 tail-call optimization for higher-order functions
                 represented as processes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency; confluence; linear types; pi-calculus;
                 process calculi",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1)",
}

@Article{Codish:1999:SGD,
  author =       "Michael Codish and Harald S{\o}ndergaard and Peter J.
                 Stuckey",
  title =        "Sharing and groundness dependencies in logic
                 programs",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "5",
  pages =        "948--976",
  month =        sep,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-5/p948-codish/p948-codish.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-5/p948-codish/",
  abstract =     "We investigate Jacobs and Langen's Sharing domain,
                 introduced for the analysis of variable sharing in
                 logic programs, and show that it is isomorphic to
                 Marriott and S{\o}ndergaard's Pos domain, introduced
                 for the analysis of groundness dependencies. Our key
                 idea is to view the sets of variables in a Sharing
                 domain element as the models of a corresponding Boolean
                 function. This leads to a recasting of sharing analysis
                 in terms of the property of `not being affected by the
                 binding of a single variable.' Such an `unaffectedness
                 dependency' analysis has close connections with
                 groundness dependency analysis using positive Boolean
                 functions. This new view improves our understanding of
                 sharing analysis, and leads to an elegant expression of
                 its combination with groundness dependency analysis
                 based on the reduced product of Sharing and Pos. It
                 also opens up new avenues for the efficient
                 implementation of sharing analysis, for example using
                 reduced order binary decision diagrams, as well as
                 efficient implementation of the reduced product, using
                 domain factorizations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; Boolean functions; dataflow
                 analysis; global analysis; groundless analysis;
                 groundness analysis; program analysis; sharing
                 analysis",
  subject =      "Software --- Programming Techniques --- Logic
                 Programming (D.1.6); Software --- Programming Languages
                 --- Processors (D.3.4): {\bf Compilers}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Optimization}; 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 Logics of programs}",
}

@Article{Gloy:1999:PPU,
  author =       "Nikolas Gloy and Michael D. Smith",
  title =        "Procedure placement using temporal-ordering
                 information",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "5",
  pages =        "977--1027",
  month =        sep,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-5/p977-gloy/p977-gloy.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-5/p977-gloy/",
  abstract =     "Instruction cache performance is important to
                 instruction fetch efficiency and overall processor
                 performance. The layout of an executable has a
                 substantial effect on the cache miss rate and the
                 instruction working set size during execution. This
                 means that the performance of an executable can be
                 improved by applying a code-placement algorithm that
                 minimizes instruction cache conflicts and improves
                 spatial locality. We describe an algorithm for
                 procedure placement, one type of code placement, that
                 significantly differs from previous approaches in the
                 type of information used to drive the placement
                 algorithm. In particular, we gather temporal-ordering
                 information that summarizes the interleaving of
                 procedures in a program trace. Our algorithm uses this
                 information along with cache configuration and
                 procedure size information to better estimate the
                 conflict cost of a potential procedure ordering. It
                 optimizes the procedure placement for single level and
                 multilevel caches. In addition to reducing instruction
                 cache conflicts, the algorithm simultaneously minimizes
                 the instruction working set size of the program. We
                 compare the performance of our algorithm with a
                 particularly successful procedure-placement algorithm
                 and show noticeable improvements in the instruction
                 cache behavior, while maintaining the same instruction
                 working set size.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code placement; conflict misses; temporal profiling;
                 working-set optimization",
  subject =      "Hardware --- Memory Structures --- Performance
                 Analysis and Design Aids** (B.3.3): {\bf Simulation**};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization}",
}

@Article{Young:1999:SCB,
  author =       "Cliff Young and Michael D. Smith",
  title =        "Static correlated branch prediction",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "5",
  pages =        "1028--1075",
  month =        sep,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-5/p1028-young/p1028-young.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-5/p1028-young/",
  abstract =     "Recent work in history-based branch prediction uses
                 novel hardware structures to capture branch correlation
                 and increase branch prediction accuracy. {\em Branch
                 correlation\/} occurs when the outcome of a conditional
                 branch can be accurately predicted by observing the
                 outcomes of previously executed branches in the dynamic
                 instruction stream. In this article, we show how to
                 instrument a program so that it is practical to collect
                 run-time statistics that indicate where branch
                 correlation occurs, and we then show how to use these
                 statistics to transform the program so that its static
                 branch prediction accuracy is improved. The run-time
                 information that we gather is called a {\em path
                 profile}, and it summarizes how often each executed
                 sequence of program points occurs in the program trace.
                 Our path profiles are more general than those
                 previously proposed. The code transformation that we
                 present is called {\em static correlated branch
                 prediction\/} (SCBP). It exhibits better branch
                 prediction accuracy than previously thought possible
                 for static prediction techniques. Furthermore, through
                 the use of an overpruning heuristic, we show that it is
                 possible to determine automatically an appropriate
                 trade-off between code expansion and branch
                 predictability so that our transformation improves the
                 performance of multiple-issue, deeply pipelined
                 microprocessors like those being built today.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "branch correlation; branch prediction; path profiling;
                 profile-driven optimization",
  subject =      "Hardware --- Control Structures and Microprogramming
                 --- Control Design Styles (B.1.1); Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Computer Systems Organization --- Processor
                 Architectures --- Single Data Stream Architectures
                 (C.1.1): {\bf RISC/CISC, VLIW architectures}; Software
                 --- Programming Languages --- Processors (D.3.4): {\bf
                 Optimization}",
}

@Article{Bottoni:1999:SDC,
  author =       "P. Bottoni and M. F. Costabile and P. Mussio",
  title =        "Specification and dialogue control of visual
                 interaction through visual rewriting systems",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "6",
  pages =        "1077--1136",
  month =        nov,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/1999-21-6/p1077-bottoni/p1077-bottoni.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/1999-21-6/p1077-bottoni/",
  abstract =     "Computers are increasingly being seen not only as
                 computing tools but more so as communication tools,
                 thus placing special emphasis on human-computer
                 interaction (HCI). In this article, the focus is on
                 visual HCI, where the messages exchanged between human
                 and computer are images appearing on the computer
                 screen, as usual in current popular user interfaces. We
                 formalize interactive sessions of a human-computer
                 dialogue as a structured set of legal visual sentences,
                 i.e., as a visual language, and show how rewriting
                 systems can be generalized to specify both the
                 pictorial and the computational aspects of visual
                 languages. To this end, Visual Conditional Attributed
                 Rewriting (VCARW) systems are introduced, and use for
                 specification of visual languages. These specifications
                 are given as inputs to a procedure illustrated in the
                 article as a system of algorithms, which automatically
                 generates control mechanisms of the interaction, thus
                 favoring the design of more reliable and usable
                 systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "control automaton, dialogue control, visual
                 languages",
  subject =      "Software --- Programming Techniques --- Visual
                 Programming (D.1.7); Software --- Software Engineering
                 --- Design Tools and Techniques (D.2.2): {\bf User
                 interfaces}; Software --- Software Engineering ---
                 Programming Environments (D.2.6): {\bf Interactive
                 environments}; Theory of Computation --- Mathematical
                 Logic and Formal Languages --- Grammars and Other
                 Rewriting Systems (F.4.2); Information Systems ---
                 Information Interfaces and Presentation --- User
                 Interfaces (H.5.2): {\bf Interaction styles};
                 Information Systems --- Information Interfaces and
                 Presentation --- User Interfaces (H.5.2): {\bf
                 User-centered design}",
}

@Article{Decorte:1999:CBT,
  author =       "Stefaan Decorte and Danny {De Schreye} and Henk
                 Vandecasteele",
  title =        "Constraint-based termination analysis of logic
                 programs",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "6",
  pages =        "1137--1195",
  month =        nov,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-6/p1137-decorte/",
  abstract =     "Current norm-based automatic termination analysis
                 techniques for logic programs can be split up into
                 different components: inference of mode or type
                 information, derivation of models, generation of
                 well-founded orders, and verification of the
                 termination conditions themselves. Although providing
                 high-precision results, these techniques suffer from an
                 efficiency point of view, as several of these analyses
                 are often performed through abstract interpretation. We
                 present a new termination analysis which integrates the
                 various components and produces a set of constraints
                 that, when solvable, identifies successful termination
                 proofs. The proposed method is both efficient and
                 precise. The use of constraint sets enables the
                 propagation on information over all different phases
                 while the need for multiple analyses is considerably
                 reduced.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "constraint solving, logic programming, termination
                 analysis",
  subject =      "Computing Methodologies --- Artificial Intelligence
                 --- Automatic Programming (I.2.2); Computing
                 Methodologies --- Artificial Intelligence --- Deduction
                 and Theorem Proving (I.2.3)",
}

@Article{Freund:1999:TSO,
  author =       "Stephen N. Freund and John C. Mitchell",
  title =        "The type system for object initialization in the
                 {Java} bytecode language",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "6",
  pages =        "1196--1250",
  month =        nov,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-6/p1196-freund/",
  abstract =     "In the standard Java implementation, a Java language
                 program is compiled to Java bytecode. This bytecode may
                 be sent across the network to another site, where it is
                 then executed by the Java Virtual Machine. Since
                 bytecode may be written by hand, or corrupted during
                 network transmission, the Java Virtual Machine contains
                 a bytecode verifier that performs a number of
                 consistency checks before code is run. These checks
                 include type correctness and, as illustrated by
                 previous attacks on the Java Virtual Machine, are
                 critical for system security. In order to analyze
                 existing bytecode verifiers and to understand the
                 properties that should be verified, we develop a
                 precise specification of statically correct Java
                 bytecode, in the form of a type system. Our focus in
                 this article is a subset of the bytecode language
                 dealing with object creation and initialization. For
                 this subset, we prove, that, for every Java bytecode
                 program that satisfies our typing constraints, every
                 object is initialized before it is used. The type
                 system is easily combined with a previous system
                 developed by Stata and Abadi for bytecode subroutines.
                 Our analysis of subroutines and object initialization
                 reveals a previously unpublished bug in the Sun JDK
                 bytecode verifier.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "bytecode languages; Java; object initialization; type
                 checking",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1); 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 --- Studies of Program
                 Constructs (F.3.3): {\bf Type structure}",
}

@Article{Kandemir:1999:GCO,
  author =       "M. Kandemir and P. Banerjee and A. Choudhary and J.
                 Ramanujam and N. Shenoy",
  title =        "A global communication optimization technique based on
                 data-flow analysis and linear algebra",
  journal =      j-TOPLAS,
  volume =       "21",
  number =       "6",
  pages =        "1251--1297",
  month =        nov,
  year =         "1999",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/1999-21-6/p1251-kandemir/",
  abstract =     "Reducing communication overhead is extremely important
                 in distributed-memory message-passing architectures. In
                 this article, we present a technique to improve
                 communication that considers data access patterns of
                 the entire program. Our approach is based on a
                 combination of traditional data-flow analysis and a
                 linear algebra framework, and it works on structured
                 programs with conditional statements and nested loops
                 but without arbitrary goto statements.The distinctive
                 features of the solution are the accuracy in keeping
                 communication set information, support for general
                 alignments and distributions including block-cyclic
                 distributions, and the ability to simulate some of the
                 previous approaches with suitable modifications. We
                 also show how optimizations such as message
                 vectorization, message coalescing, and redundancy
                 elimination are supported by our framework.
                 Experimental results on several benchmarks show that
                 our technique is effective in reducing the number of
                 messages (an average of 32\% reduction), the volume of
                 the data communicated (an average of 37\% reduction),
                 and the execution time (an average of 26\%
                 reduction).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "communication optimizations; data-flow analysis;
                 distributed-memory machines; global optimizations;
                 message vectorization; parallelism",
  subject =      "Software --- Software Engineering --- Programming
                 Environments (D.2.6): {\bf Integrated environments};
                 Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Frameworks};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}",
}

@Article{Pierce:2000:LTI,
  author =       "Benjamin C. Pierce and David N. Turner",
  title =        "Local type inference",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "1",
  pages =        "1--44",
  month =        jan,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-1/p1-pierce/",
  abstract =     "We study two partial type inference methods for a
                 language combining subtyping and impredicative
                 polymorphism. Both methods are {\em local\/} in the
                 sense that missing annotations are recovered using only
                 information from adjacent nodes in the syntax tree,
                 without long-distance constraints such as unification
                 variables. One method infers type arguments in
                 polymorphic applications using a local constraint
                 solver. The other infers annotations on bound variables
                 in function abstractions by propagating type
                 constraints downward from enclosing application nodes.
                 We motivate our design choices by a statistical
                 analysis of the uses of type inference in a sizable
                 body of existing ML code.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "polymorphism; subtyping; type inference",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1)",
}

@Article{Fokkink:2000:LRE,
  author =       "Wan Fokkink and Jasper Kamperman and Pum Walters",
  title =        "Lazy rewriting on eager machinery",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "1",
  pages =        "45--86",
  month =        jan,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-1/p45-fokkink/",
  abstract =     "The article introduces a novel notion of lazy
                 rewriting. By annotating argument positions as lazy,
                 redundant rewrite steps are avoided, and the
                 termination behavior of a term-rewriting system can be
                 improved. Some transformations of rewrite rules enable
                 an implementation using the same primitives as an
                 implementation of eager rewriting.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "innermost reduction; lazy rewriting; specificity
                 ordering",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization}",
}

@Article{Kuperman:2000:ATA,
  author =       "Orna Kuperman and Moshe Y. Vardi",
  title =        "An automata-theoretic approach to modular model
                 checking",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "1",
  pages =        "87--128",
  month =        jan,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-1/p87-kuperman/",
  abstract =     "In {\em modular verification\/} the specification of a
                 module consists of two part. One part describes the
                 guaranteed behavior of the module. The other part
                 describes the assumed behavior of the system in which
                 the module is interacting. This is called the {\em
                 assume-guarantee\/} paradigm. In this paper we consider
                 assume-guarantee specifications in which the guarantee
                 is specified by branching temporal formulas. We
                 distinguish between two approaches. In the first
                 approach, the assumption is specified by branching
                 temporal formulas too. In the second approach, the
                 assumption is specified by linear temporal logic. We
                 consider guarantees in CTL, and CTL*. We develop two
                 fundamental techniques: building maximal models for CTL
                 and CTL* formulas and using alternating automata to
                 obtain space-efficient algorithms for fair model
                 checking. Using these techniques we classify the
                 complexity of satisfiability, validity, implication,
                 and modular verification for CTL and CTL*. We show that
                 modular verification is PSPACE-complete for CTL and is
                 EXSPACE-complete for CTL*. We prove that when the
                 assumption is linear, these bounds hold also for
                 guarantees in CTL and CTL*. On the other hand, the
                 problem remains EXSPACE-hard even when we restrict the
                 assumptions to LTL and take the guarantees as a fixed
                 CTL formula.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "automata; modular verification; temporal logic",
  subject =      "Software --- Software Engineering --- Software/Program
                 Verification (D.2.4)",
}

@Article{Shao:2000:ESS,
  author =       "Zhong Shao and Andrew W. Appel",
  title =        "Efficient and safe-for-space closure conversion",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "1",
  pages =        "129--161",
  month =        jan,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-1/p129-shao/",
  abstract =     "Modern compilers often implement function calls (or
                 returns) in two steps: first, a ``closure'' environment
                 is properly installed to provide access for free
                 variables in the target program fragment; second, the
                 control is transferred to the target by a ``jump with
                 arguments (for results).'' Closure conversion--which
                 decides where and how to represent closures at
                 runtime--is a crucial step in the compilation of
                 functional languages. This paper presents a new
                 algorithm that exploits the use of compile-time control
                 and data-flow information to optimize function calls.
                 By extensive closure sharing and allocation by 36\% and
                 memory fetches for local and global variables by 43\%;
                 and improves the already efficient code generated by an
                 earlier version of the Standard ML of New Jersey
                 compiler by about 17\% on a DECstation 5000. Moreover,
                 unlike most other approaches, our new
                 closure-allocation scheme the strong {\em
                 safe-for-space-complexity\/} rule, thus achieving good
                 asymptotic space usage.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "callee-save registers; closure conversion; closure
                 representation; compiler optimization; flow analysis;
                 heap-based compilation; space safety",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Procedures,
                 functions, and subroutines}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Compilers};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Optimization}",
}

@Article{Reps:2000:UCS,
  author =       "Thomas Reps",
  title =        "Undecidability of context-sensitive data-independence
                 analysis",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "1",
  pages =        "162--186",
  month =        jan,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-1/p162-reps/",
  abstract =     "A number of program-analysis problems can be tackled
                 by transforming them into certain kinds of
                 graph-reachability problems in labeled graphs. The edge
                 labels can be used to filter out paths that are not
                 interest: a path $P$ from vertex $t$ only counts as a
                 ``valid connection'' between $s$ and $t$ if the word
                 spelled out by $P$ is in a certain language. Often the
                 languages used for such filtering purposes are
                 languages of matching parentheses. In some cases, the
                 matched-parenthesis condition is used for paths with
                 mismatched calls and returns. This leads to so-called
                 ``context-{\em sensitive\/}'' program analyses, such as
                 context-{\em sensitive\/} interprocedural slicing and
                 context-{\em sensitive\/} interprocedural dataflow
                 analysis. In other cases, the matched-parenthesis
                 condition is used to capture a graph-theoretic analog
                 of McCarthy's rules: ``car (cons(x,y)) = x'' and
                 ``cdr(cons(x,y)) =y''. That is, in the code
                 fragment\par

                 c = cons(a,b); d = car(c);\par

                 \noindent the fact that there is a
                 ``structure-transmitted data-dependence'' from a to d,
                 but not from b to d, is captured in a graph by (1)
                 using a vertex for each variable, (2) an edge from
                 vertex $i$ to vertex $j$ when $i$ is used on the
                 right-hand side of an assignment to $j$, (3)
                 parentheses that match as the labels on the edges that
                 run from a to c and c to d, and (4) parentheses that do
                 not match as the labels on the edges that run from a to
                 c and c to d. However, structure-transmitted
                 data-independence analysis is context-{\em
                 insensitive}, because there are no constraints that
                 these two kinds of uses of parentheses can be combined
                 to create a context-{\em sensitive\/} analysis for
                 structure-transmitted data-dependences. This article
                 answers the question in the negative: in general, the
                 problem of context {\em sensitive},
                 structure-transmitted data-dependence analysis is
                 undecidable. The results imply that in general, both
                 context-{\em sensitive\/} set-based analysis and -CFA
                 (when data constructors and selectors and selectors are
                 taken into account) are also undecidable.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization};
                 Theory of Computation --- Mathematical Logic and Formal
                 Languages --- Mathematical Logic (F.4.1): {\bf
                 Computability theory}; Theory of Computation ---
                 Mathematical Logic and Formal Languages --- Formal
                 Languages (F.4.3): {\bf Decision problems}; Mathematics
                 of Computing --- Discrete Mathematics --- Graph Theory
                 (G.2.2): {\bf Path and circuit problems}",
}

@Article{Hermenegildo:2000:IAC,
  author =       "Manuel Hermenegildo and German Puebla and Kim Marriott
                 and Peter J. Stuckey",
  title =        "Incremental analysis of constraint logic programs",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "187--223",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p187-hermenegildo/",
  abstract =     "Global analyzers traditionally read and analyze the
                 entire program at once, in a nonincremental way.
                 However, there are many situations which are not well
                 suited to this simple model and which instead require
                 reanalysis of certain parts of a program which has
                 already been analyzed. In these cases, it appears
                 inefficient to perform the analysis of the program
                 again from scratch, as needs to be done with current
                 systems. We describe how the fixed-point algorithms
                 used in current generic analysis engines for
                 (constraint) logic programming languages can be
                 extended to support incremental analysis. The possible
                 changes to a program are classified into three types:
                 addition, deletion, and arbitrary change. For each one
                 of these, we provide one or more algorithms for
                 identifying the parts of the analysis that must be
                 recomputed and for performing the actual recomputation.
                 The potential benefits and drawbacks of these
                 algorithms are discussed. Finally, we present some
                 experimental results obtained with an implementation of
                 the algorithms in the PLAI generic abstract
                 interpretation framework. The results show significant
                 benefits when using the proposed incremental analysis
                 algorithms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; constraint logic programming;
                 incremental computation; static analysis",
  subject =      "Software --- Programming Techniques --- Automatic
                 Programming (D.1.2); Software --- Programming
                 Techniques --- Logic Programming (D.1.6); Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Theory of Computation --- Logics and
                 Meanings of Programs --- Specifying and Verifying and
                 Reasoning about Programs (F.3.1): {\bf Logics of
                 programs}",
}

@Article{Sperber:2000:GLP,
  author =       "Michael Sperber and Peter Thiemann",
  title =        "Generation of {LR} parsers by partial evaluation",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "224--264",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p224-sperber/",
  abstract =     "The combination of modern programming languages and
                 partial evaluation yields new approaches to old
                 problems. In particular, the combination of functional
                 programming and partial evaluation can turn a general
                 parser into a parser generator. We use an inherently
                 functional approach to implement general LR($k$)
                 parsers and specialize them with respect to the input
                 grammars using offline partial evaluation. The
                 functional specification of LR parsing yields a concise
                 implementation of the algorithms themselves.
                 Furthermore, we demonstrate the elegance of the
                 functional approach by incorporating on-the-fly
                 attribute evaluation for S-attributed grammars and two
                 schemes for error recovery, which lend themselves to
                 natural and elegant implementation. The parser require
                 only minor changes to achieve good specialization
                 results. The generated parsers have production quality
                 and match those produced by traditional parser
                 generators in sped and compactness",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "continuations; functional programming; LR parsing;
                 parser generation; partial evaluation",
  subject =      "Software --- Programming Techniques --- Applicative
                 (Functional) Programming (D.1.1); Software ---
                 Programming Techniques --- Automatic Programming
                 (D.1.2); Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Applicative
                 (functional) languages}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Parsing}; Theory
                 of Computation --- Mathematical Logic and Formal
                 Languages --- Grammars and Other Rewriting Systems
                 (F.4.2): {\bf Parsing}; Computing Methodologies ---
                 Artificial Intelligence --- Automatic Programming
                 (I.2.2): {\bf Program transformation}; Computing
                 Methodologies --- Artificial Intelligence --- Automatic
                 Programming (I.2.2): {\bf Program synthesis}",
}

@Article{Moreira:2000:FMJ,
  author =       "Jos{\'e} E. Moreira and Samuel P. Midkiff and Manish
                 Gupta",
  title =        "From flop to megaflops: {Java} for technical
                 computing",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "265--295",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p265-moreira/",
  abstract =     "Although there has been some experimentation with Java
                 as a language for numerically intensive computing,
                 there is a perception by many that the language is
                 unsuited for such work because of performance
                 deficiencies. In this article we show how optimizing
                 array bounds checks and null pointer checks creates
                 loop nests on which aggressive optimizations can be
                 used. Applying these optimizations by hand to a simple
                 matrix-multiply test case leads to Java-compliant
                 programs whose performance is in excess of 500 Mflops
                 on a four-processor 332MHz RS/6000 model F50 computer.
                 We also report in this article the effect that various
                 optimizations have on the performance of six
                 floating-point-intensive benchmarks. Through these
                 optimizations we have been able to achieve with Java at
                 least 80\% of the peak Fortran performance on the same
                 benchmarks. Since all of these optimizations can be
                 automated, we conclude that Java will soon be a serious
                 contender for numerically intensive computing.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "arrays; compilers; Java",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Run-time
                 environments}; Software --- Programming Techniques ---
                 Concurrent Programming (D.1.3): {\bf Parallel
                 programming}; Software --- Programming Languages ---
                 Language Classifications (D.3.2): {\bf Java}",
}

@Article{DeLaBanda:2000:ICL,
  author =       "Mar{\'\i} Garc{\'\i}a {De La Banda} and Manuel
                 Hermengildo and Kim Marriott",
  title =        "Independence in {CLP} languages",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "296--339",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p296-garcia_de_la_banda/",
  abstract =     "Studying independence of goals has proven very useful
                 in the context of logic programming. In particular, it
                 has provided a formal basis for powerful automatic
                 parallelization tools, since independence ensures that
                 two goals may be evaluated in parallel while preserving
                 correctness and efficiency. We extend the concept of
                 independence to constraint logic programs (CLP) and
                 prove that it also ensures the correctness and
                 efficiency of the parallel evaluation of independent
                 goals. Independence for CLP languages is more complex
                 than for logic programming as search space preservation
                 is necessary but no longer sufficient for ensuring
                 correctness and efficiency. Two additional issues
                 arise. The first is that the cost of constraint solving
                 may depend upon the order constraints are encountered.
                 The second is the need to handle dynamic scheduling. We
                 clarify these issues by proposing various types of
                 search independence and constraint solver independence,
                 and show how they can be combined to allow different
                 optimizations, from parallelism to intelligent
                 backtracking. Sufficient conditions for independence
                 which can be evaluated ``a priori'' at run-time are
                 also proposed. Our study also yields new insights into
                 independence in logic programming languages. In
                 particular, we show that search space preservation is
                 not only a sufficient but also a necessary condition
                 for ensuring correctness and efficiency of parallel
                 execution.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "constraint logic programming; independence;
                 parallelism",
  subject =      "Software --- Programming Techniques --- Automatic
                 Programming (D.1.2); Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3): {\bf
                 Parallel programming}; Software --- Programming
                 Techniques --- Logic Programming (D.1.6); Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Specifying and Verifying and Reasoning about Programs
                 (F.3.1): {\bf Logics of programs}",
}

@Article{Leroy:2000:TBA,
  author =       "Xavier Leroy and Fran{\c{c}}ois Pessaux",
  title =        "Type-based analysis of uncaught exceptions",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "340--377",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p340-leroy/",
  abstract =     "This article presents a program analysis to estimate
                 uncaught exceptions in ML programs. This analysis
                 relies on unification-based type inference in a
                 nonstandard type system, using rows to approximate both
                 the flow of escaping exceptions (a la effect systems)
                 and the flow of result values (a la control-flow
                 analyses). The resulting analysis is efficient and
                 precise; in particular, arguments carried by exceptions
                 are accurately handled.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "CAML; exceptions; polymorphism; rows; SML; static
                 debugging; type and effect systems; type inference",
  subject =      "Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Error handling and recovery};
                 Software --- Software Engineering --- Testing and
                 Debugging (D.2.5): {\bf Symbolic execution}; Software
                 --- Programming Languages --- Language Classifications
                 (D.3.2): {\bf Applicative (functional) languages};
                 Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf ML}; Theory of
                 Computation --- Logics and Meanings of Programs ---
                 Semantics of Programming Languages (F.3.2): {\bf
                 Program analysis}; 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 ---
                 Studies of Program Constructs (F.3.3): {\bf Control
                 primitives}; Theory of Computation --- Logics and
                 Meanings of Programs --- Studies of Program Constructs
                 (F.3.3): {\bf Type structure}",
}

@Article{Debray:2000:CTC,
  author =       "Saumya K. Debray and William Evans and Robert Muth and
                 Bjorn {De Sutter}",
  title =        "Compiler techniques for code compaction",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "378--415",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p378-debray/",
  abstract =     "In recent years there has been an increasing trend
                 toward the incorporation of computers into a variety of
                 devices where the amount of memory available is
                 limited. This makes it desirable to try to reduce the
                 size of applications where possible. This article
                 explores the use of compiler techniques to accomplish
                 code compaction to yield smaller executables. The main
                 contribution of this article is to show that careful,
                 aggressive, interprocedural optimization, together with
                 procedural abstraction of repeated code fragments, can
                 yield significantly better reductions in code size than
                 previous approaches, which have generally focused on
                 abstraction of repeated instruction sequences. We also
                 show how ``equivalent'' code fragments can be detected
                 and factored out using conventional compiler
                 techniques, and without having to resort to purely
                 linear treatments of code sequences as in
                 suffix-tree-based approaches, thereby setting up a
                 framework for code compaction that can be more flexible
                 in its treatment of what code fragments are considered
                 equivalent. Our ideas have been implemented in the form
                 of a binary-rewriting tool that reduces the size of
                 executables by about 30\% on the average.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code compaction; code compression; code size
                 reduction",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Code generation}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}; Data --- Coding
                 and Information Theory (E.4): {\bf Data compaction and
                 compression}",
}

@Article{Ramalingam:2000:CSS,
  author =       "G. Ramalingam",
  title =        "Context-sensitive synchronization-sensitive analysis
                 is undecidable",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "2",
  pages =        "416--430",
  month =        mar,
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 26 10:12:58 MDT 2000",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-2/p416-ramalingam/",
  abstract =     "Static program analysis is concerned with the
                 computation of approximations of the runtime behavior
                 of programs. Precise information about a program's
                 runtime behavior is, in general, uncomputable for
                 various different reasons, and each reason may
                 necessitate making certain approximations in the
                 information computed. This article illustrates one
                 source of difficulty in static analysis of concurrent
                 programs. Specifically, the article shows that an
                 analysis that is simultaneously both context-sensitive
                 and synchronization-sensitive (that is, a
                 context-sensitive analysis that precisely takes into
                 account the constraints on execution order imposed by
                 the synchronization statements in the program) is
                 impossible even for the simplest of analysis
                 problems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization};
                 Theory of Computation --- Mathematical Logic and Formal
                 Languages --- Mathematical Logic (F.4.1): {\bf
                 Computability theory}; Theory of Computation ---
                 Mathematical Logic and Formal Languages ---
                 Mathematical Logic (F.4.1); Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3)",
}

@Article{Lueh:2000:FBR,
  author =       "Guei-Yuan Lueh and Thomas Gross and Ali-Reza
                 Adl-Tabatabai",
  title =        "Fusion-based register allocation",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "3",
  pages =        "431--470",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-3/p431-lueh/p431-lueh.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-3/p431-lueh/",
  abstract =     "The register allocation phase of a compiler maps live
                 range of a program to registers. If there are more
                 candidates than there are physical registers, the
                 registers allocator must spill a live range (the home
                 location is in memory) or split a live range (the live
                 range occupies multiple locations). One of the
                 challenges for a register allocator is to deal with
                 spilling and splitting together. Fusion-based register
                 allocation uses the structure of the program to make
                 splitting and spilling decisions, with the goal to move
                 overhead operations to infrequently executed parts of a
                 program. The basic idea of fusion-based register
                 allocation is to build up the interference graph.
                 Starting with some base region (e.g., a basic block, a
                 loop), the register allocator adds basic blocks to the
                 region and incrementally builds the interference graph.
                 When there are more live ranges than registers, the
                 register allocator selects live ranges to split; these
                 live ranges are split along the edge that was most
                 recently added to the region. This article describes
                 fusion-based register allocation in detail and compares
                 it with other approaches to register allocation. For
                 programs from the SPEC92 suite, fusion-based register
                 allocation can improve the execution time (of optimized
                 programs, for the MIPS architecture) by up to 8.4\%
                 over Chaitin-style register allocation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Management",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "performance evaluation; register allocation",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Code generation}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Optimization}",
}

@Article{Clausen:2000:JBC,
  author =       "Lars R{\ae}der Clausen and Ulrik Pagh Schultz and
                 Charles Consel and Gilles Muller",
  title =        "{Java} bytecode compression for low-end embedded
                 systems",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "3",
  pages =        "471--489",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-3/p471-clausen/p471-clausen.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-3/p471-clausen/",
  abstract =     "A program executing on a low-end embedded system, such
                 as a smart-card, faces scarce memory resources and
                 fixed execution time constraints. We demonstrate that
                 factorization of common instruction sequences in Java
                 bytecode allows the memory footprint to be reduced, on
                 average, to 85\% of its original size, with a minimal
                 execution time penalty. While preserving Java
                 compatibility, our solution requires only a few
                 modifications which are straightforward to implement in
                 any JVM used in a low-end embedded system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Design; Experimentation",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code compression; embedded systems; Java bytecode",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Optimization}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Interpreters};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Run-time environments}",
}

@Article{Kistler:2000:ADM,
  author =       "Thomas Kistler and Michael Franz",
  title =        "Automated data-member layout of heap objects to
                 improve memory-hierarchy performance",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "3",
  pages =        "490--505",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-3/p490-kistler/p490-kistler.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-3/p490-kistler/",
  abstract =     "We present and evaluate a simple, yet efficient
                 optimization technique that improves memory-hierarchy
                 performance for pointer-centric applications by up to
                 24\% and reduces cache misses by up to 35\%. This is
                 achieved by selecting an improved ordering for the data
                 members of pointer-based data structures. Our
                 optimization is applicable to all type-safe programming
                 languages that completely abstract from physical
                 storage layout; examples of such languages are Java and
                 Oberon. Our technique does not involve programmers in
                 the optimization process, but runs fully automatically,
                 guided by dynamic profiling information that captures
                 which paths through the program are taken with that
                 frequency. The algorithm first strives to cluster data
                 members that are accessed closely after one another
                 onto the same cache line, increasing spatial locality.
                 Then, the data members that have been mapped to a
                 particular cache line are ordered to minimize load
                 latency in case of a cache miss.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dynamic data structures; dynamic optimization;
                 memory-hierarchy optimization",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Optimization}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Run-time
                 environments}",
}

@Article{Wellings:2000:IOO,
  author =       "A. J. Wellings and B. Johnson and B. Sanden and J.
                 Kienzle and T. Wolf and S. Michell",
  title =        "Integrating object-oriented programming and protected
                 objects in {Ada 95}",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "3",
  pages =        "506--539",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-3/p506-wellings/p506-wellings.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-3/p506-wellings/",
  abstract =     "Integrating concurrent and object-oriented programming
                 has been an active research topic since the late
                 1980's. There is a now a plethora of methods for
                 achieving this integration. The majority of approaches
                 have taken a sequential object-oriented language and
                 made it concurrent. A few approaches have taken a
                 concurrent language and made it object-oriented. The
                 most important of this latter class is the Ada 95
                 language, which is an extension to the object-based
                 concurrent programming language Ada 83. Arguably, Ada
                 95 does not fully integrate its models of concurrency
                 and object-oriented programming. For example, neither
                 tasks nor protected objects are extensible. This
                 article discusses ways in which protected objects can
                 be made more extensible.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Ada 95; concurrency; concurrent object-oriented
                 programming; inheritance anomaly",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Concurrent
                 programming structures}; Software --- Programming
                 Languages --- Language Constructs and Features (D.3.3):
                 {\bf Inheritance}",
}

@Article{Snelting:2000:UCH,
  author =       "Gregor Snelting and Frank Tip",
  title =        "Understanding class hierarchies using concept
                 analysis",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "3",
  pages =        "540--582",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-3/p540-snelting/p540-snelting.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-3/p540-snelting/",
  abstract =     "A new method is presented for analyzing and
                 reengineering class hierarchies. In our approach, a
                 class hierarchy is processed along with a set of
                 applications that use it, and a fine-grained analysis
                 of the access and subtype relationships between
                 objects, variables, and class members is performed. The
                 result of this analysis is again a class hierarchy,
                 which is guaranteed to be behaviorally equivalent to
                 the original hierarchy, but in which each object only
                 contains the members that are required. Our method is
                 semantically well-founded in {\em concept analysis\/}:
                 the new class hierarchy is a minimal and maximally
                 factorized {\em concept lattice\/} that reflects the
                 access and subtype relationships between variables,
                 objects and class members. The method is primarily
                 intended as a tool for finding imperfections in the
                 design of class hierarchies, and can be used as the
                 basis for tools that largely automate the process of
                 reengineering such hierarchies. The method can also be
                 used as a space-optimizing source-to-source
                 transformation that removes redundant fields from
                 objects. A prototype implementation for Java has been
                 constructed, and used to conduct several case studies.
                 Our results demonstrate that the method can provide
                 valuable insights into the usage of a class hierarchy
                 in a specific context, and lead to useful restructuring
                 proposals.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Documentation; Experimentation; Languages;
                 Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "class hierarchy reengineering; concept analysis",
  subject =      "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 Classes and
                 objects}; Theory of Computation --- Logics and Meanings
                 of Programs --- Semantics of Programming Languages
                 (F.3.2): {\bf Program analysis}",
}

@Article{Assmann:2000:GRS,
  author =       "Uwe Assmann",
  title =        "Graph rewrite systems for program optimization",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "4",
  pages =        "583--637",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-4/p583-assmann/",
  abstract =     "Graph rewrite systems can be used to specify and
                 generate program optimizations. For termination of the
                 systems several rule-based criteria are developed,
                 defining {\em exhaustive graph rewrite systems}. For
                 nondeterministic systems {\em stratification\/} is
                 introduced which automatically selects single normal
                 forms. To illustrate how far the methodology reaches,
                 parts of the lazy code motion optimization are
                 specified. The resulting graph rewrite system classes
                 can be evaluated by a uniform algorithm, which forms
                 the basis for the optimizer generator OPTIMIX. With
                 this tool several optimizer components have been
                 generated, and some numbers on their speed are
                 presented.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Performance; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compiler generators; graph rewrite systems; program
                 analysis; program optimization; program transformation;
                 specification; stratification; very high-level
                 languages; visual programming",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Translator writing systems and compiler
                 generators}",
}

@Article{Qian:2000:SFI,
  author =       "Zhenyu Qian",
  title =        "Standard fixpoint iteration for {Java} bytecode
                 verification",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "4",
  pages =        "638--672",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-4/p638-qian/",
  abstract =     "Java bytecode verification forms the basis for
                 Java-based Internet security and needs a rigorous
                 description. One important aspect of bytecode
                 verification is to check if a Java Virtual Machine
                 (JVM) program is statically well-typed. So far, several
                 formal specifications have been proposed to define what
                 the static well-typedness means. This paper takes a
                 step further and presents a chaotic fixpoint iteration,
                 which represents a family of fixpoint computation
                 strategies to compute a least type for each JVM program
                 within a finite number of iteration steps. Since a
                 transfer function in the iteration is not monotone, we
                 choose to follow the example of a nonstandard fixpoint
                 theorem, which requires that all transfer functions are
                 increasing, and monotone in case the bigger element is
                 already a fixpoint. The resulting least type is the
                 artificial top element if and only if he JVM program is
                 not statically well-typed. The iteration is standard
                 and close to Sun's informal specification and most
                 commercial bytecode verifiers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "bytecode verification; dataflow analysis; fixpoint;
                 Java",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1)",
}

@Article{Tang:2000:PTR,
  author =       "Hong Tang and Kai Shen and Tao Yang",
  title =        "Program transformation and runtime support for
                 threaded {MPI} execution on shared-memory machines",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "4",
  pages =        "673--700",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-4/p673-tang/",
  abstract =     "Parallel programs written in MPI have been widely used
                 for developing high-performance applications on various
                 platforms. Because of a restriction of the MPI
                 computation model, conventional MPI implementations on
                 shared-memory machines map each MPI node to an OS
                 process, which can suffer serious performance
                 degradation in the presence of multiprogramming. This
                 paper studies compile-time and runtime techniques for
                 enhancing performance portability of MPI code running
                 on multiprogrammed shared-memory machines. The proposed
                 techniques allow MPI nodes to be executed safety and
                 efficiently as threads. Compile-time transformation
                 eliminates global and static variables in C code using
                 node-specific data. The runtime support includes an
                 efficient and provably correct communication protocol
                 that uses lock-free data structure and takes advantage
                 of address space sharing among threads. The experiments
                 on SGI Origin 2000 show that our MPI prototype called
                 TMPI using the proposed techniques is competitive with
                 SGI's native MPI implementation in a dedicated
                 environment, and that it has significant performance
                 advantages in a multiprogrammed environment.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Design; Experimentation; Languages;
                 Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "lock-free synchronization; MPI; multiprogrammed
                 environments; program transformation; shared-memory
                 machines; threaded execution",
  subject =      "Hardware --- Memory Structures --- Design Styles
                 (B.3.2): {\bf Shared memory}; Software --- Programming
                 Techniques --- Concurrent Programming (D.1.3): {\bf
                 Parallel programming}; Software --- Programming
                 Languages --- Language Classifications (D.3.2): {\bf
                 Concurrent, distributed, and parallel languages};
                 Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Preprocessors}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Run-time
                 environments}; Software --- Operating Systems ---
                 Process Management (D.4.1): {\bf
                 Multiprocessing/multiprogramming/multitasking}; Data
                 --- Data Structures (E.1): {\bf Lists, stacks, and
                 queues}",
}

@Article{Walker:2000:TMM,
  author =       "David Walker and Karl Crary and Greg Morrisett",
  title =        "Typed memory management via static capabilities",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "4",
  pages =        "701--771",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2000-22-4/p701-walker/",
  abstract =     "Region-based memory management is an alternative to
                 standard tracing garbage collection that makes
                 operation such as memory deallocation explicit but
                 verifiably safe. In this article, we present a new
                 compiler intermediate language, called the Capability
                 Language (CL), that supports region-based memory
                 management and enjoys a provably safe type systems.
                 Unlike previous region-based type system, region
                 lifetimes need not be lexically scoped, and yet the
                 language may be checked for safety without complex
                 analyses. Therefore, our type system may be deployed in
                 settings such as extensible operating systems where
                 both the performance and safety of untrusted code is
                 important. The central novelty of the language is the
                 use of static capabilities to specify the
                 permissibility of various operations, such as memory
                 access and deallocation. In order to ensure
                 capabilities are relinquished properly, the type system
                 tracks aliasing information using a form of bounded
                 quantification. Moreover, unlike previous work on
                 region-based type systems, the proof of soundness of
                 our type system is relatively simple, employing only
                 standard syntactic techniques. In order to show how our
                 language may be used in practice, we show how to
                 translate a variant of Tofte and Talpin's high-level
                 type-and-effects system for region-based memory
                 management into our language. When combined with known
                 region inference algorithms, this translation provides
                 a way to compile source-level languages to CL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "certified code; region-based memory management;
                 type-directed compilation; typed intermediate
                 languages",
  subject =      "Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Semantics};
                 Software --- Programming Languages --- Formal
                 Definitions and Theory (D.3.1): {\bf Syntax}; Software
                 --- Programming Languages --- Processors (D.3.4): {\bf
                 Compilers}; 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 ---
                 Studies of Program Constructs (F.3.3): {\bf Type
                 structure}",
}

@Article{Quillere:2000:OMU,
  author =       "Fabien Quiller{\'e} and Sanjay Rajopadhye",
  title =        "Optimizing memory usage in the polyhedral model",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "5",
  pages =        "773--815",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-5/p773-quillere/p773-quillere.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-5/p773-quillere/",
  abstract =     "The {\em polyhedral model\/} provides a single unified
                 foundation for systolic array synthesis and automatic
                 parallelization of loop programs. We investigate the
                 problem of memory reuse when compiling Alpha (a
                 functional language based on this model). Direct
                 compilation would require unacceptably large memory
                 (for example $ O(n^3) $ for matrix multiplication).
                 Researchers have previously addressed the problem of
                 memory reuse, and the analysis that this entails for
                 projective memory allocations. This paper addresses,
                 for a given schedule, the choice of the projections so
                 as to minimize the volume of the residual memory. We
                 prove tight bounds on the number of linearly
                 independent projection vectors. Our method is
                 constructive, yielding an optimal memory allocation. We
                 extend the method to modular functions, and deal with
                 the subsequent problems of code generation. Our ideas
                 are illustrated on a number of examples generated by
                 the current version of the Alpha compiler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "affine recurrence equations; applicative (functional)
                 languages; automatic parallelization; data-parallel
                 languages; dataflow analysis; dependence analysis;
                 lifetime analysis; memory management; parallel code
                 generation; polyhedral model; scheduling",
  subject =      "Computer Systems Organization --- Processor
                 Architectures --- Multiple Data Stream Architectures
                 (Multiprocessors) (C.1.2): {\bf Array and vector
                 processors}; Software --- Programming Languages ---
                 Processors (D.3.4): {\bf Compilers}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Memory management (garbage collection)}",
}

@Article{vonHanxleden:2000:BCP,
  author =       "Reinhard von Hanxleden and Ken Kennedy",
  title =        "A balanced code placement framework",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "5",
  pages =        "816--860",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-5/p816-von_hanxleden/p816-von_hanxleden.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-5/p816-von_hanxleden/",
  abstract =     "Give-N-Take is a code placement framework which uses a
                 generic producer-consumer mechanism. An instance of
                 this could be a communication step between a processor
                 that computes (produces) some data, and other
                 processors that subsequently reference (consume) these
                 data in an expression. An advantage of Give-N-Take over
                 traditional partial redundancy elimination techniques
                 is its concept of production {\em regions}, instead of
                 single locations, which can be beneficial for general
                 latency hiding. Give-N-Take also guarantees {\em
                 balanced\/} production, i.e., each production will be
                 started and stopped exactly once. The framework can
                 also take advantage of production coming ``for free,''
                 as induced by side effects, without disturbing balance.
                 Give-N-Take can place production either before or after
                 consumption, and it also provides the option to
                 speculatively hoist code out of potentially zero-trip
                 loop (nest) constructs. Give-N-Take uses a fast
                 elimination method based on Tarjan intervals, with a
                 complexity linear in the program size in most cases. We
                 have implemented Give-N-Take as part of a Fortran D
                 compiler prototype, where it solves various
                 communication generation problems associated with
                 compiling data-parallel languages onto
                 distributed-memory architectures.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "data-flow analysis; Fortran D; high performance
                 Fortran; latency hiding; partial redundancy
                 elimination; Tarjan intervals",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Code generation}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Optimization}",
}

@Article{Dovier:2000:SCL,
  author =       "Agostino Dovier and Carla Piazza and Enrico Pontelli
                 and Gianfranco Rossi",
  title =        "Sets and constraint logic programming",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "5",
  pages =        "861--931",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-5/p861-dovier/p861-dovier.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-5/p861-dovier/",
  abstract =     "In this paper we present a study of the problem of
                 handling constraints made by conjunctions of positive
                 and negative literals based on the predicate symbols =,
                 , and (i.e., disjointness of two sets) in a (hybrid)
                 universe of {\em finite sets}. We also review and
                 compare the main techniques considered to represent
                 finite sets in the context of logic languages. The
                 resulting constraint algorithms are embedded in a
                 Constraint Logic Programming (CLP) language which
                 provides finite sets--along with basic set-theoretic
                 operations--as first-class objects of the language. The
                 language--called CLP(SET)--is an instance of the
                 general CLP framework, and as such it inherits all the
                 general features and theoretical results of this
                 scheme. We provide, through programming examples, a
                 taste of the expressive power offered by programming in
                 CLP(SET).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Theory",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "computable set theory; constraints; declarative
                 programming",
  subject =      "Software --- Programming Languages --- Language
                 Classifications (D.3.2): {\bf Constraint and logic
                 languages}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3); Theory of
                 Computation --- Mathematical Logic and Formal Languages
                 --- Mathematical Logic (F.4.1): {\bf Logic and
                 constraint programming}; Theory of Computation ---
                 Mathematical Logic and Formal Languages (F.4); Theory
                 of Computation --- Mathematical Logic and Formal
                 Languages --- Mathematical Logic (F.4.1): {\bf Set
                 theory}",
}

@Article{Grant:2000:BCD,
  author =       "Brian Grant and Markus Mock and Matthai Philipose and
                 Craig Chambers and Susan J. Eggers",
  title =        "The benefits and costs of {DyC}'s run-time
                 optimizations",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "5",
  pages =        "932--972",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 17 10:05:24 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-5/p932-grant/p932-grant.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-5/p932-grant/",
  abstract =     "DyC selectively dynamically compiles programs during
                 their execution, utilizing the run-time-computed values
                 of variables and data structures to apply optimizations
                 that are based on partial evaluation. The dynamic
                 optimizations are preplanned at static compile time in
                 order to reduce their run-time cost; we call this {\em
                 staging}. DyC's staged optimizations include (1) an
                 advanced binding-time analysis that supports
                 polyvariant specialization (enabling both single-way
                 and multiway complete loop unrolling), polyvariant
                 division, static loads, and static calls, (2) low-cost,
                 dynamic versions of traditional global optimizations,
                 such as zero and copy propagation and dead-assignment
                 elimination, and (3) dynamic peephole optimizations,
                 such as strength reduction. Because of this large suite
                 of optimizations and its low dynamic compilation
                 overhead, DyC achieves good performance improvements on
                 programs that are larger and more complex than the
                 kernels previously targeted by other dynamic
                 compilation systems. This paper evaluates the benefits
                 and costs of applying DyC's optimizations. We assess
                 their impact on the performance of a variety of small
                 to medium-sized programs, both for the regions of code
                 that are actually transformed and for the entire
                 application as a whole. Our study includes an analysis
                 of the contribution to performance of individual
                 optimizations, the performance effect of changing the
                 applications' inputs, and a detailed accounting of
                 dynamic compilation costs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Performance",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dynamic compilation; specialization",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization}",
}

@Article{Madhavan:2000:EGG,
  author =       "Maya Madhavan and Priti Shankar and Siddhartha Rai and
                 U. Ramakrishna",
  title =        "Extending {Graham-Glanville} techniques for optimal
                 code generation",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "6",
  pages =        "973--1001",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jul 25 13:55:50 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-6/p973-madhavan/p973-madhavan.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-6/p973-madhavan/",
  abstract =     "We propose a new technique for constructing
                 code-generator generators, which combines the
                 advantages of the Graham-Glanville parsing technique
                 and the bottom-up tree parsing approach. Machine
                 descriptions are similar to Yacc specifications. The
                 construction effectively generates a pushdown automaton
                 as the matching device. This device is able to handle
                 ambiguous grammars, and can be used to generate locally
                 optimal code without the use of heuristics. Cost
                 computations are performed at preprocessing time. The
                 class of regular tree grammars augmented with costs
                 that can be handled by our system properly includes
                 those that can be handled by bottom-up systems based on
                 finite-state tree parsing automata. Parsing time is
                 linear in the size of the subject tree. We have tested
                 the system on specifications for some systems and
                 report table sizes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "code-generator generator; optimal code generation;
                 tree pattern matching",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Code generation}; Software ---
                 Programming Languages --- Processors (D.3.4): {\bf
                 Retargetable compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Translator
                 writing systems and compiler generators}",
}

@Article{Apt:2000:RCC,
  author =       "Krzysztof R. Apt",
  title =        "The role of commutativity in constraint propagation
                 algorithms",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "6",
  pages =        "1002--1036",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jul 25 13:55:50 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-6/p1002-apt/p1002-apt.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-6/p1002-apt/",
  abstract =     "Constraint propagation algorithms form an important
                 part of most of the constraint programming systems. We
                 provide here a simple, yet very general framework that
                 allows us to explain several constraint propagation
                 algorithms in a systematic way. In this framework we
                 proceed in two steps. First, we introduce a generic
                 iteration algorithm on partial orderings and prove its
                 correctness in an abstract setting. Then we instantiate
                 this algorithm with specific partial orderings and
                 functions to obtain specific constraint propagation
                 algorithms. In particular, using the notions
                 commutativity and semi-commutativity, we show that the
                 AC-3, PC-2, DAC, and DPC algorithms for achieving
                 (directional) arc consistency and (directional) path
                 consistency are instances of a single generic
                 algorithm. The work reported here extends and
                 simplifies that of Apt [1999a].",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Algorithms; Languages; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "commutativity; constraint propagation; generic
                 algorithms",
  subject =      "Software --- Programming Languages --- Language
                 Constructs and Features (D.3.3): {\bf Constraints};
                 Computing Methodologies --- Symbolic and Algebraic
                 Manipulation --- Algorithms (I.1.2): {\bf Analysis of
                 algorithms}; Computing Methodologies --- Artificial
                 Intelligence --- Automatic Programming (I.2.2): {\bf
                 Program synthesis}",
}

@Article{Grossman:2000:STA,
  author =       "Dan Grossman and Greg Morrisett and Steve Zdancewic",
  title =        "Syntactic type abstraction",
  journal =      j-TOPLAS,
  volume =       "22",
  number =       "6",
  pages =        "1037--1080",
  year =         "2000",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jul 25 13:55:50 MDT 2001",
  bibsource =    "http://www.acm.org/pubs/toc/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/articles/journals/toplas/2000-22-6/p1037-grossman/p1037-grossman.pdf;
                 http://www.acm.org/pubs/citations/journals/toplas/2000-22-6/p1037-grossman/",
  abstract =     "Software developers often structure programs in such a
                 way that different pieces of code constitute distinct
                 {\em principals}. Types help define the protocol by
                 which these principals interact. In particular, {\em
                 abstract types\/} allow a principal to make strong
                 assumptions about how well-typed clients use the
                 facilities that it provides. We show how the notions of
                 principals and type abstraction can be formalized
                 within a language. Different principals can know the
                 implementation of different abstract types. We use
                 additional syntax to track the flow of values with
                 abstract types during the evaluation of a program and
                 demonstrate how this framework supports syntactic
                 proofs (in the style of subject reduction) for
                 type-abstraction properties. Such properties have
                 traditionally required semantic arguments; using syntax
                 avoids the need to build a model and recursive types
                 for the language. We present various typed lambda
                 calculi with principals, including versions that have
                 mutable state and recursive types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  generalterms = "Languages; Security; Theory; Verification",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "operational semantics; parametricity; proof
                 techniques; syntactic proofs; type abstraction",
  subject =      "Software --- Software Engineering --- Software
                 Architectures (D.2.11): {\bf Information hiding};
                 Software --- Software Engineering --- Software
                 Architectures (D.2.11): {\bf Languages (e.g.,
                 description, interconnection, definition)}; Software
                 --- Programming Languages --- Formal Definitions and
                 Theory (D.3.1): {\bf Syntax}; Software --- Programming
                 Languages --- Formal Definitions and Theory (D.3.1):
                 {\bf Semantics}; Software --- Programming Languages ---
                 Language Constructs and Features (D.3.3): {\bf Abstract
                 data types}; 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 ---
                 Studies of Program Constructs (F.3.3): {\bf Type
                 structure}",
}

@Article{Bistarelli:2001:SBC,
  author =       "Stefano Bistarelli and Ugo Montanari and Francesca
                 Rossi",
  title =        "Semiring-based constraint logic programming: syntax
                 and semantics",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "1",
  pages =        "1--29",
  month =        jan,
  year =         "2001",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/383721.383725",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 1 17:09:35 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We extend the Constraint Logic Programming (CLP)
                 formalism in order to handle semiring-based
                 constraints. This allows us to perform in the same
                 language both constraint solving and optimization. In
                 fact, constraints based on semirings are able to model
                 both classical constraint solving and more
                 sophisticated features like uncertainty, probability,
                 fuzziness, and optimization. We then provide this class
                 of languages with three equivalent semantics:
                 model-theoretic, fix-point, and proof-theoretic, in the
                 style of classical CLP programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Diwan:2001:UTA,
  author =       "Amer Diwan and Kathryn S. McKinley and J. Eliot B.
                 Moss",
  title =        "Using types to analyze and optimize object-oriented
                 programs",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "1",
  pages =        "30--72",
  month =        jan,
  year =         "2001",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/383721.383732",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 1 17:09:35 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Object-oriented programming languages provide many
                 software engineering benefits, but these often come at
                 a performance cost. Object-oriented programs make
                 extensive use of method invocations and pointer
                 dereferences, both of which are potentially costly on
                 modern machines. We show how to use types to produce
                 effective, yet simple, techniques that reduce the costs
                 of these features in Modula-3, a statically typed,
                 object-oriented language. Our compiler performs
                 type-based alias analysis to disambiguate memory
                 references. It uses the results of the type-based alias
                 analysis to eliminate redundant memory references and
                 to replace monomorphic method invocation sites with
                 direct calls. Using limit, static, and running time
                 evaluation, we demonstrate that these techniques are
                 effective, and sometimes perfect for a set of Modula-3
                 benchmarks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leung:2001:STC,
  author =       "Allen Leung and Krishna V. Palem and Amir Pnueli",
  title =        "Scheduling time-constrained instructions on pipelined
                 processors",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "1",
  pages =        "73--103",
  month =        jan,
  year =         "2001",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/383721.383733",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 1 17:09:35 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this work we investigate the problem of scheduling
                 instructions on idealized microprocessors with multiple
                 pipelines, in the presence of precedence constraints,
                 release-times, deadlines, and latency constraints. A
                 latency of $ l_{ij} $ specifies that there must be at
                 least $ l_{ij} $ time-steps between the completion time
                 of instruction $i$ and the start time of instruction
                 $j$. A latency of $ l_{ij} = - 1$ can be used to
                 specify that $j$ may be scheduled concurrently with $i$
                 but not earlier. We present a generic algorithm that
                 runs in $ O(n^2 \log n \alpha (n) + n e)$ time, given
                 $n$ instructions and $e$ edges in the precedence DAG,
                 where $ \alpha (n)$ is the functional inverse of the
                 Ackermann function. Our algorithm can be used to
                 construct feasible schedules for various classes of
                 instances, including instances with the following
                 configurations: (1) one pipeline, with individual
                 release-times and deadlines and where the latencies
                 between instructions are restricted to 0 and 1; (2) $m$
                 pipelines, with individual release-times and deadlines,
                 and monotone-interval order precedences; (3) two
                 pipelines with latencies of $ - 1$ or $0$, and
                 release-times and deadlines; (4) one pipeline,
                 latencies of $0$ or $1$ and individual processing times
                 that are at least one; (5) $m$ pipelines, intree
                 precedences, constant latencies, and deadlines; (6) $m$
                 pipelines, outtree precedences, constant latencies, and
                 release-times. For instances with deadlines, optimal
                 schedules that minimize the maximal tardiness can be
                 constructed using binary search, in $ O(\log n)$
                 iterations of our algorithm. We obtain our results
                 using backward scheduling, a very general relaxation
                 method, which extends, unifies, and clarifies many
                 previous results on instruction scheduling for
                 pipelined and parallel machines.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ryder:2001:SIM,
  author =       "Barbara G. Ryder and William A. Landi and Philip A.
                 Stocks and Sean Zhang and Rita Altucher",
  title =        "A schema for interprocedural modification side-effect
                 analysis with pointer aliasing",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "2",
  pages =        "105--186",
  month =        mar,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:55 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "http://www.acm.org/pubs/citations/journals/toplas/2001-23-1/p105-ryder/",
  abstract =     "The first interprocedural modification side-effects
                 analysis for C (MOD $c$) that obtains better than
                 worst-case precision on programs with general-purpose
                 pointer usage is presented with empirical results. The
                 analysis consists of an algorithm schema corresponding
                 to a family of MOD $c$ algorithms with two independent
                 phases: one for determining pointer-induced aliases and
                 a subsequent one for propagating interprocedural side
                 effects. These MOD $c$ algorithms are parameterized by
                 the aliasing method used. The empirical results compare
                 the performance of two dissimilar MOD $c$ algorithms:
                 MOD $c$ ({\em FSAlias\/}) uses a flow-sensitive,
                 calling-context-sensitive interprocedural alias
                 analysis MOD $c$ ({\em Fs\/}) a flow-insensitive, alias
                 analysis which is much faster, but less accurate. These
                 two algorithms were profiled on 45 programs ranging in
                 size from 250 to 30,000 lines of C code, and the
                 results demonstrate dramatically the possible
                 cost-precision trade-offs. This {\em first
                 comparative\/} implementation of MOD $c$ analyses
                 offers insight into the differences between {\em
                 flow-/context-sensitive\/} and {\em
                 flow-/context-insensitive\/} analyses. The analysis
                 cost versus precision trade-offs in side-effect
                 information obtained are reported. The results show
                 surprisingly that the precision of flow-sensitive
                 side-effect analysis is not always prohibitive in cost,
                 and that the precision of flow-insensitive analysis is
                 substantially better than worst-case estimates and
                 seems sufficient for certain applications. On average
                 MOD $c$ ({\em FSAlias\/}) for procedures and calls is
                 in the range of 20\% more precise than MOD $c$ ({\em
                 FIAlias\/}); however, the performance was found to be
                 at least an order of magnitude slower than MOD $c$
                 ({\em FIAlias\/}).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  subject =      "Software --- Programming Languages --- Processors
                 (D.3.4): {\bf Compilers}; Software --- Programming
                 Languages --- Processors (D.3.4): {\bf Optimization};
                 Theory of Computation --- Logics and Meanings of
                 Programs --- Semantics of Programming Languages
                 (F.3.2): {\bf Program analysis}",
}

@Article{Attie:2001:SCP,
  author =       "Paul C. Attie and E. Allen Emerson",
  title =        "Synthesis of concurrent programs for an atomic
                 read\slash write model of computation",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "2",
  pages =        "187--242",
  month =        mar,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:55 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Knoblock:2001:TES,
  author =       "Todd B. Knoblock and Jakob Rehof",
  title =        "Type elaboration and subtype completion for {Java}
                 bytecode",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "2",
  pages =        "243--272",
  month =        mar,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:55 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alur:2001:MCH,
  author =       "Rajeev Alur and Mihalis Yannakakis",
  title =        "Model checking of hierarchical state machines",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "3",
  pages =        "273--303",
  month =        may,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:56 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Etalle:2001:TCP,
  author =       "Sandro Etalle and Maurizio Gabbrielli and Maria Chiara
                 Meo",
  title =        "Transformations of {CCP} programs",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "3",
  pages =        "304--395",
  month =        may,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:56 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Igarashi:2001:FJM,
  author =       "Atsushi Igarashi and Benjamin C. Pierce and Philip
                 Wadler",
  title =        "Featherweight {Java}: a minimal core calculus for
                 {Java} and {GJ}",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "3",
  pages =        "396--450",
  month =        may,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:56 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kim:2001:ERV,
  author =       "Ik-Soon Kim and Kwang-Moo Choe",
  title =        "Error repair with validation in {LR}-based parsing",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "4",
  pages =        "451--471",
  month =        jul,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:56 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gupta:2001:PEP,
  author =       "Gopal Gupta and Enrico Pontelli and Khayri A. M. Ali
                 and Mats Carlsson and Manuel V. Hermenegildo",
  title =        "Parallel execution of {Prolog} programs: a survey",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "4",
  pages =        "472--602",
  month =        jul,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Feb 19 15:41:56 MST 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cooper:2001:OSR,
  author =       "Keith D. Cooper and L. Taylor Simpson and Christopher
                 A. Vick",
  title =        "Operator strength reduction",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "5",
  pages =        "603--625",
  month =        sep,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 9 14:09:24 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Paulson:2001:MTP,
  author =       "Lawrence C. Paulson",
  title =        "Mechanizing a theory of program composition for
                 {UNITY}",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "5",
  pages =        "626--656",
  month =        sep,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 9 14:09:24 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Appel:2001:IMR,
  author =       "Andrew W. Appel and David McAllester",
  title =        "An indexed model of recursive types for foundational
                 proof-carrying code",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "5",
  pages =        "657--683",
  month =        sep,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 9 14:09:24 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grove:2001:FCG,
  author =       "David Grove and Craig Chambers",
  title =        "A framework for call graph construction algorithms",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "6",
  pages =        "685--746",
  month =        nov,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Maassen:2001:EJR,
  author =       "Jason Maassen and Rob {Van Nieuwpoort} and Ronald
                 Veldema and Henri Bal and Thilo Kielmann and Ceriel
                 Jacobs and Rutger Hofman",
  title =        "Efficient {Java RMI} for parallel programming",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "6",
  pages =        "747--775",
  month =        nov,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{VanderZanden:2001:LLA,
  author =       "Bradley T. {Vander Zanden} and Richard Halterman and
                 Brad A. Myers and Rich McDaniel and Rob Miller and
                 Pedro Szekely and Dario A. Giuse and David Kosbie",
  title =        "Lessons learned about one-way, dataflow constraints in
                 the {Garnet} and {Amulet} graphical toolkits",
  journal =      j-TOPLAS,
  volume =       "23",
  number =       "6",
  pages =        "776--796",
  month =        nov,
  year =         "2001",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lee:2002:ADC,
  author =       "Peizong Lee and Zvi Meir Kedem",
  title =        "Automatic data and computation decomposition on
                 distributed memory parallel computers",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "1",
  pages =        "1--50",
  month =        jan,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Henzinger:2002:AGR,
  author =       "Thomas A. Henzinger and Shaz Qadeer and Sriram K.
                 Rajamani and Serdar Tasiran",
  title =        "An assume-guarantee rule for checking simulation",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "1",
  pages =        "51--64",
  month =        jan,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Paek:2002:EPA,
  author =       "Yunheung Paek and Jay Hoeflinger and David Padua",
  title =        "Efficient and precise array access analysis",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "1",
  pages =        "65--109",
  month =        jan,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:01 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fisher:2002:GE,
  author =       "Kathleen Fisher and Benjamin C. Pierce",
  title =        "Guest editorial",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "2",
  pages =        "111--111",
  month =        mar,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:02 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{League:2002:TPC,
  author =       "Christopher League and Zhong Shao and Valery
                 Trifonov",
  title =        "Type-preserving compilation of {Featherweight Java}",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "2",
  pages =        "112--152",
  month =        mar,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:02 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Drossopoulou:2002:MDO,
  author =       "Sophia Drossopoulou and Ferruccio Damiani and
                 Mariangiola Dezani-Ciancaglini and Paola Giannini",
  title =        "More dynamic object reclassification: {{\em
                 Fickle\/}$_\parallel $}",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "2",
  pages =        "153--191",
  month =        mar,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:02 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moore:2002:AC,
  author =       "J. Strother Moore and George Porter",
  title =        "The apprentice challenge",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "3",
  pages =        "193--216",
  month =        may,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:02 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sagiv:2002:PSA,
  author =       "Mooly Sagiv and Thomas Reps and Reinhard Wilhelm",
  title =        "Parametric shape analysis via $3$-valued logic",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "3",
  pages =        "217--298",
  month =        may,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 1 06:48:02 MDT 2002",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Unger:2002:HIL,
  author =       "Sebastian Unger and Frank Mueller",
  title =        "Handling irreducible loops: optimized node splitting
                 versus {DJ}-graphs",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "4",
  pages =        "299--333",
  month =        jul,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{VanDenBrand:2002:CLD,
  author =       "M. G. J. {Van Den Brand} and J. Heering and P. Klint
                 and P. A. Olivier",
  title =        "Compiling language definitions: the {ASF+SDF}
                 compiler",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "4",
  pages =        "334--368",
  month =        jul,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:2002:ADC,
  author =       "Anonymous",
  title =        "Automatic derivation of compiler machine
                 descriptions",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "4",
  pages =        "369--408",
  month =        jul,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jimenez:2002:RTN,
  author =       "Marta Jim{\'e}nez and Jos{\'e} M. Llaber{\'\i}a and
                 Agust{\'\i}n Fern{\'a}ndez",
  title =        "Register tiling in nonrectangular iteration spaces",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "4",
  pages =        "409--453",
  month =        jul,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:2002:LDD,
  author =       "Anonymous",
  title =        "On loops, dominators, and dominance frontiers",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "5",
  pages =        "455--490",
  month =        sep,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leino:2002:DAI,
  author =       "K. Rustan M. Leino and Greg Nelson",
  title =        "Data abstraction and information hiding",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "5",
  pages =        "491--553",
  month =        sep,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Charlesworth:2002:UAC,
  author =       "Arthur Charlesworth",
  title =        "The undecidability of associativity and commutativity
                 analysis",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "5",
  pages =        "554--565",
  month =        sep,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hennessy:2002:IFV,
  author =       "Matthew Hennessy and James Riely",
  title =        "Information flow vs. resource access in the
                 asynchronous pi-calculus",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "5",
  pages =        "566--591",
  month =        sep,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:45 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hirzel:2002:UTL,
  author =       "Martin Hirzel and Amer Diwan and Johannes Henkel",
  title =        "On the usefulness of type and liveness accuracy for
                 garbage collection and leak detection",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "6",
  pages =        "593--624",
  month =        nov,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tip:2002:PET,
  author =       "Frank Tip and Peter F. Sweeney and Chris Laffra and
                 Aldo Eisma and David Streeter",
  title =        "Practical extraction techniques for {Java}",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "6",
  pages =        "625--666",
  month =        nov,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Yang:2002:EEB,
  author =       "Minghui Yang and Gang-Ryung Uh and David B. Whalley",
  title =        "Efficient and effective branch reordering using
                 profile data",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "6",
  pages =        "667--697",
  month =        nov,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Corchuelo:2002:RSE,
  author =       "Rafael Corchuelo and Jos{\'e} A. P{\'e}rez and Antonio
                 Ruiz and Miguel Toro",
  title =        "Repairing syntax errors in {LR} parsers",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "6",
  pages =        "698--710",
  month =        nov,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Duggan:2002:TSL,
  author =       "Dominic Duggan",
  title =        "Type-Safe linking with recursive {DLLs} and shared
                 libraries",
  journal =      j-TOPLAS,
  volume =       "24",
  number =       "6",
  pages =        "711--804",
  month =        nov,
  year =         "2002",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Levi:2003:MSA,
  author =       "Francesca Levi and Davide Sangiorgi",
  title =        "Mobile safe ambients",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "1",
  pages =        "1--69",
  month =        jan,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rugina:2003:PAS,
  author =       "Radu Rugina and Martin C. Rinard",
  title =        "Pointer analysis for structured parallel programs",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "1",
  pages =        "70--116",
  month =        jan,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pottier:2003:IFI,
  author =       "Fran{\c{c}}ois Pottier and Vincent Simonet",
  title =        "Information flow inference for {ML}",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "1",
  pages =        "117--158",
  month =        jan,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Saha:2003:IAQ,
  author =       "Bratin Saha and Valery Trifonov and Zhong Shao",
  title =        "Intensional analysis of quantified types",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "2",
  pages =        "159--209",
  month =        mar,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ramsey:2003:TAB,
  author =       "Norman Ramsey and Cristina Cifuentes",
  title =        "A transformational approach to binary translation of
                 delayed branches",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "2",
  pages =        "210--224",
  month =        mar,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bruce:2003:PTS,
  author =       "Kim B. Bruce and Angela Schuett and Robert van Gent
                 and Adrian Fiech",
  title =        "{PolyTOIL}: a type-safe polymorphic object-oriented
                 language",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "2",
  pages =        "225--290",
  month =        mar,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:46 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rhiger:2003:FEL,
  author =       "Morten Rhiger",
  title =        "A foundation for embedded languages",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "3",
  pages =        "291--315",
  month =        may,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:47 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rinard:2003:ESB,
  author =       "Martin C. Rinard and Pedro C. Diniz",
  title =        "Eliminating synchronization bottlenecks using adaptive
                 replication",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "3",
  pages =        "316--359",
  month =        may,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:47 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fournet:2003:SIT,
  author =       "Cedric Fournet and Andrew D. Gordon",
  title =        "Stack inspection: {Theory} and variants",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "3",
  pages =        "360--399",
  month =        may,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Apr 9 18:34:47 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Damiani:2003:RIT,
  author =       "Ferruccio Damiani",
  title =        "Rank $2$ intersection types for local definitions and
                 conditional expressions",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "4",
  pages =        "401--451",
  month =        jul,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 07:03:33 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Schultz:2003:APS,
  author =       "Ulrik P. Schultz and Julia L. Lawall and Charles
                 Consel",
  title =        "Automatic program specialization for {Java}",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "4",
  pages =        "452--499",
  month =        jul,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 07:03:33 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kistler:2003:CPO,
  author =       "Thomas Kistler and Michael Franz",
  title =        "Continuous program optimization: a case study",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "4",
  pages =        "500--548",
  month =        jul,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 07:03:33 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Amadio:2003:RDC,
  author =       "Roberto M. Amadio and G{\'e}rard Boudol and C{\'e}dric
                 Lhoussaine",
  title =        "The receptive distributed {$ \pi $}-calculus",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "5",
  pages =        "549--577",
  month =        sep,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 26 19:13:26 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Spoto:2003:CAA,
  author =       "Fausto Spoto and Thomas Jensen",
  title =        "Class analyses as abstract interpretations of trace
                 semantics",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "5",
  pages =        "578--630",
  month =        sep,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 26 19:13:26 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jeffery:2003:GLS,
  author =       "Clinton L. Jeffery",
  title =        "Generating {LR} syntax error messages from examples",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "5",
  pages =        "631--640",
  month =        sep,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 26 19:13:26 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ancona:2003:JDJ,
  author =       "Davide Ancona and Giovanni Lagorio and Elena Zucca",
  title =        "{Jam}---designing a {Java} extension with mixins",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "5",
  pages =        "641--712",
  month =        sep,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 26 19:13:26 MDT 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Blanchet:2003:EAJ,
  author =       "Bruno Blanchet",
  title =        "Escape analysis for {Java$^{TM}$}: {Theory} and
                 practice",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "6",
  pages =        "713--775",
  month =        nov,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 11:56:31 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Menon:2003:FSA,
  author =       "Vijay Menon and Keshav Pingali and Nikolay Mateev",
  title =        "Fractal symbolic analysis",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "6",
  pages =        "776--813",
  month =        nov,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 11:56:31 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Christensen:2003:EJH,
  author =       "Aske Simon Christensen and Anders M{\o}ller and
                 Michael I. Schwartzbach",
  title =        "Extending {Java} for high-level {Web} service
                 construction",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "6",
  pages =        "814--875",
  month =        nov,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 11:56:31 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Choi:2003:SAS,
  author =       "Jong-Deok Choi and Manish Gupta and Mauricio J.
                 Serrano and Vugranam C. Sreedhar and Samuel P.
                 Midkiff",
  title =        "Stack allocation and synchronization optimizations for
                 {Java} using escape analysis",
  journal =      j-TOPLAS,
  volume =       "25",
  number =       "6",
  pages =        "876--910",
  month =        nov,
  year =         "2003",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 11:56:31 MST 2003",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fernandez:2004:ICS,
  author =       "Antonio J. Fern{\'a}ndez and Patricia M. Hill",
  title =        "An interval constraint system for lattice domains",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "1--46",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gorlatch:2004:SRC,
  author =       "Sergei Gorlatch",
  title =        "Send-receive considered harmful: {Myths} and realities
                 of message passing",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "47--56",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bugliesi:2004:ACM,
  author =       "Michele Bugliesi and Giuseppe Castagna and Silvia
                 Crafa",
  title =        "Access control for mobile agents: {The} calculus of
                 boxed ambients",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "57--124",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Attie:2004:SFT,
  author =       "Paul C. Attie and Anish Arora and E. Allen Emerson",
  title =        "Synthesis of fault-tolerant concurrent programs",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "125--185",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wu:2004:ETC,
  author =       "Pei-Chi Wu",
  title =        "On exponential-time completeness of the circularity
                 problem for attribute grammars",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "186--190",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Christensen:2004:OPE,
  author =       "Niels H. Christensen and Robert Gl{\"u}ck",
  title =        "Offline partial evaluation can be as accurate as
                 online partial evaluation",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "1",
  pages =        "191--220",
  month =        jan,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sun Jan 11 10:26:05 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chen:2004:LGS,
  author =       "Yifeng Chen and J. W. Sanders",
  title =        "Logic of global synchrony",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "2",
  pages =        "221--262",
  month =        mar,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Vera:2004:FAF,
  author =       "Xavier Vera and Nerina Bermudo and Josep Llosa and
                 Antonio Gonz{\'a}lez",
  title =        "A fast and accurate framework to analyze and optimize
                 cache memory behavior",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "2",
  pages =        "263--300",
  month =        mar,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cortes:2004:HLA,
  author =       "Corinna Cortes and Kathleen Fisher and Daryl Pregibon
                 and Anne Rogers and Frederick Smith",
  title =        "Hancock: a language for analyzing transactional data
                 streams",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "2",
  pages =        "301--338",
  month =        mar,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alur:2004:MRH,
  author =       "Rajeev Alur and Radu Grosu",
  title =        "Modular refinement of hierarchic reactive machines",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "2",
  pages =        "339--369",
  month =        mar,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lieberherr:2004:TOS,
  author =       "Karl Lieberherr and Boaz Patt-Shamir and Doug
                 Orleans",
  title =        "Traversals of object structures: {Specification} and
                 efficient implementation",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "2",
  pages =        "370--412",
  month =        mar,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leuschel:2004:FIP,
  author =       "Michael Leuschel",
  title =        "A framework for the integration of partial evaluation
                 and abstract interpretation of logic programs",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "3",
  pages =        "413--463",
  month =        may,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Roychoudhury:2004:UFT,
  author =       "Abhik Roychoudhury and K. Narayan Kumar and C. R.
                 Ramakrishnan and I. V. Ramakrishnan",
  title =        "An unfold\slash fold transformation framework for
                 definite logic programs",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "3",
  pages =        "464--509",
  month =        may,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Glesner:2004:NSS,
  author =       "Sabine Glesner and Wolf Zimmermann",
  title =        "Natural semantics as a static program analysis
                 framework",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "3",
  pages =        "510--577",
  month =        may,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Keen:2004:JFD,
  author =       "Aaron W. Keen and Tingjian Ge and Justin T. Maris and
                 Ronald A. Olsson",
  title =        "{JR}: {Flexible} distributed programming in an
                 extended {Java}",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "3",
  pages =        "578--608",
  month =        may,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:29 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Mirani:2004:FCM,
  author =       "Rajiv Mirani and Paul Hudak",
  title =        "First-class monadic schedules",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "4",
  pages =        "609--651",
  month =        jul,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Helsen:2004:PSM,
  author =       "Simon Helsen and Peter Thiemann",
  title =        "Polymorphic specialization for {ML}",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "4",
  pages =        "652--701",
  month =        jul,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sistla:2004:SRS,
  author =       "A. Prasad Sistla and Patrice Godefroid",
  title =        "Symmetry and reduced symmetry in model checking",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "4",
  pages =        "702--734",
  month =        jul,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Park:2004:ORC,
  author =       "Jinpyo Park and Soo-Mook Moon",
  title =        "Optimistic register coalescing",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "4",
  pages =        "735--765",
  month =        jul,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Odersky:2004:GE,
  author =       "Martin Odersky and Benjamin C. Pierce",
  title =        "Guest editorial",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "5",
  pages =        "767--768",
  month =        sep,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Benton:2004:MCA,
  author =       "Nick Benton and Luca Cardelli and C{\'e}dric Fournet",
  title =        "Modern concurrency abstractions for {C\#}",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "5",
  pages =        "769--804",
  month =        sep,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Stone:2004:EOL,
  author =       "Christopher A. Stone",
  title =        "Extensible objects without labels",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "5",
  pages =        "805--835",
  month =        sep,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Millstein:2004:MTH,
  author =       "Todd Millstein and Colin Bleckner and Craig Chambers",
  title =        "Modular typechecking for hierarchically extensible
                 datatypes and functions",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "5",
  pages =        "836--889",
  month =        sep,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wand:2004:SAD,
  author =       "Mitchell Wand and Gregor Kiczales and Christopher
                 Dutchyn",
  title =        "A semantics for advice and dynamic join points in
                 aspect-oriented programming",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "5",
  pages =        "890--910",
  month =        sep,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Nov 4 08:07:30 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jay:2004:PC,
  author =       "C. Barry Jay",
  title =        "The pattern calculus",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "6",
  pages =        "911--937",
  month =        nov,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 22 07:52:03 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Thammanur:2004:FME,
  author =       "Sathyanarayanan Thammanur and Santosh Pande",
  title =        "A fast, memory-efficient register allocation framework
                 for embedded systems",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "6",
  pages =        "938--974",
  month =        nov,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 22 07:52:03 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Li:2004:ATI,
  author =       "Zhiyuan Li and Yonghong Song",
  title =        "Automatic tiling of iterative stencil loops",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "6",
  pages =        "975--1028",
  month =        nov,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 22 07:52:03 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Clements:2004:TRM,
  author =       "John Clements and Matthias Felleisen",
  title =        "A tail-recursive machine with stack inspection",
  journal =      j-TOPLAS,
  volume =       "26",
  number =       "6",
  pages =        "1029--1052",
  month =        nov,
  year =         "2004",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 22 07:52:03 MST 2004",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Shao:2005:TSC,
  author =       "Zhong Shao and Valery Trifonov and Bratin Saha and
                 Nikolaos Papaspyrou",
  title =        "A type system for certified binaries",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "1",
  pages =        "1--45",
  month =        jan,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 24 15:57:47 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hosoya:2005:RET,
  author =       "Haruo Hosoya and J{\'e}r{\^o}me Vouillon and Benjamin
                 C. Pierce",
  title =        "Regular expression types for {XML}",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "1",
  pages =        "46--90",
  month =        jan,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 24 15:57:47 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liu:2005:OAA,
  author =       "Yanhong A. Liu and Scott D. Stoller and Ning Li and
                 Tom Rothamel",
  title =        "Optimizing aggregate array computations in loops",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "1",
  pages =        "91--125",
  month =        jan,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 24 15:57:47 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Palsberg:2005:ADC,
  author =       "Jens Palsberg and Tian Zhao and Trevor Jim",
  title =        "Automatic discovery of covariant read-only fields",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "1",
  pages =        "126--162",
  month =        jan,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 24 15:57:47 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chitil:2005:PPL,
  author =       "Olaf Chitil",
  title =        "Pretty printing with lazy dequeues",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "1",
  pages =        "163--184",
  month =        jan,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 24 15:57:47 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rugina:2005:SBA,
  author =       "Radu Rugina and Martin C. Rinard",
  title =        "Symbolic bounds analysis of pointers, array indices,
                 and accessed memory regions",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "2",
  pages =        "185--235",
  month =        mar,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 12 07:09:25 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gavanelli:2005:DIK,
  author =       "Marco Gavanelli and Evelina Lamma and Paola Mello and
                 Michela Milano",
  title =        "Dealing with incomplete knowledge on {CLP({\em FD\/})}
                 variable domains",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "2",
  pages =        "236--263",
  month =        mar,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 12 07:09:25 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Igarashi:2005:RUA,
  author =       "Atsushi Igarashi and Naoki Kobayashi",
  title =        "Resource usage analysis",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "2",
  pages =        "264--313",
  month =        mar,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 12 07:09:25 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ball:2005:PPA,
  author =       "Thomas Ball and Todd Millstein and Sriram K.
                 Rajamani",
  title =        "Polymorphic predicate abstraction",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "2",
  pages =        "314--343",
  month =        mar,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 12 07:09:25 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pottier:2005:SAS,
  author =       "Fran{\c{c}}ois Pottier and Christian Skalka and Scott
                 Smith",
  title =        "A systematic approach to static access control",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "2",
  pages =        "344--382",
  month =        mar,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 12 07:09:25 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Buchsbaum:2005:CNS,
  author =       "Adam L. Buchsbaum and Haim Kaplan and Anne Rogers and
                 Jeffery R. Westbrook",
  title =        "Corrigendum: ``{A new, simpler linear-time dominators
                 algorithm}''",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "383--387",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Buchsbaum:1998:NSL}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Schulte:2005:WDB,
  author =       "Christian Schulte and Peter J. Stuckey",
  title =        "When do bounds and domain propagation lead to the same
                 search space?",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "388--425",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Das:2005:PFI,
  author =       "Dibyendu Das and U. Ramakrishna",
  title =        "A practical and fast iterative algorithm for {$ \phi
                 $}-function computation using {DJ} graphs",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "426--440",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moreau:2005:RAP,
  author =       "Luc Moreau and Christian Queinnec",
  title =        "Resource aware programming",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "441--476",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Necula:2005:CTS,
  author =       "George C. Necula and Jeremy Condit and Matthew Harren
                 and Scott McPeak and Westley Weimer",
  title =        "{CCured}: type-safe retrofitting of legacy software",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "477--526",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nguyen:2005:EEA,
  author =       "Thi Viet Nga Nguyen and Fran{\c{c}}ois Irigoin",
  title =        "Efficient and effective array bound checking",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "527--570",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hailperin:2005:CCC,
  author =       "Max Hailperin",
  title =        "Comparing conservative coalescing criteria",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "3",
  pages =        "571--582",
  month =        may,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 7 12:37:29 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Back:2005:KJR,
  author =       "Godmar Back and Wilson C. Hsieh",
  title =        "The {KaffeOS Java} runtime system",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "4",
  pages =        "583--630",
  month =        jul,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 15 14:26:27 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Zhang:2005:CPT,
  author =       "Xiangyu Zhang and Rajiv Gupta and Youtao Zhang",
  title =        "Cost and precision tradeoffs of dynamic data slicing
                 algorithms",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "4",
  pages =        "631--661",
  month =        jul,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 15 14:26:27 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hall:2005:IPA,
  author =       "Mary W. Hall and Saman P. Amarasinghe and Brian R.
                 Murphy and Shih-Wei Liao and Monica S. Lam",
  title =        "Interprocedural parallelization analysis in {SUIF}",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "4",
  pages =        "662--731",
  month =        jul,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 15 14:26:27 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Suganuma:2005:DED,
  author =       "Toshio Suganuma and Toshiaki Yasue and Motohiro
                 Kawahito and Hideaki Komatsu and Toshio Nakatani",
  title =        "Design and evaluation of dynamic optimizations for a
                 {Java} just-in-time compiler",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "4",
  pages =        "732--785",
  month =        jul,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 15 14:26:27 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alur:2005:ARS,
  author =       "Rajeev Alur and Michael Benedikt and Kousha Etessami
                 and Patrice Godefroid and Thomas Reps and Mihalis
                 Yannakakis",
  title =        "Analysis of recursive state machines",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "4",
  pages =        "786--818",
  month =        jul,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Sep 15 14:26:27 MDT 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gil:2005:EST,
  author =       "Joseph (Yossi) Gil and Yoav Zibin",
  title =        "Efficient subtyping tests with {PQ}-encoding",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "5",
  pages =        "819--856",
  month =        sep,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 18 08:33:32 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hirschowitz:2005:MMC,
  author =       "Tom Hirschowitz and Xavier Leroy",
  title =        "Mixin modules in a call-by-value setting",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "5",
  pages =        "857--881",
  month =        sep,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 18 08:33:32 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{DeSutter:2005:LTB,
  author =       "Bjorn {De Sutter} and Bruno {De Bus} and Koen {De
                 Bosschere}",
  title =        "Link-time binary rewriting techniques for program
                 compaction",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "5",
  pages =        "882--945",
  month =        sep,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 18 08:33:32 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Vera:2005:ACM,
  author =       "Xavier Vera and Jaume Abella and Josep Llosa and
                 Antonio Gonz{\'a}lez",
  title =        "An accurate cost model for guiding data locality
                 transformations",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "5",
  pages =        "946--987",
  month =        sep,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 18 08:33:32 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Boute:2005:FDL,
  author =       "Raymond Boute",
  title =        "Functional declarative language design and predicate
                 calculus: a practical approach",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "5",
  pages =        "988--1047",
  month =        sep,
  year =         "2005",
  CODEN =        "ATPSDT",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 18 08:33:32 MST 2005",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hicks:2005:DSU,
  author =       "Michael Hicks and Scott Nettles",
  title =        "Dynamic software updating",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1049--1096",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108971",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Many important applications must run continuously and
                 without interruption, and yet also must be changed to
                 fix bugs or upgrade functionality. No prior
                 general-purpose methodology for dynamic updating
                 achieves a practical balance between flexibility,
                 robustness, low overhead, ease of use, and low cost. We
                 present an approach for C-like languages that provides
                 type-safe dynamic updating of native code in an
                 extremely flexible manner---code, data, and types may
                 be updated, at programmer-determined times---and
                 permits the use of automated tools to aid the
                 programmer in the updating process. Our system is based
                 on dynamic patches that contain both the updated code
                 and the code needed to transition from the old version
                 to the new. A novel aspect of our patches is that they
                 consist of verifiable native code (e.g. Proof-Carrying
                 Code or Typed Assembly Language), which is native code
                 accompanied by annotations that allow online
                 verification of the code's safety. We discuss how
                 patches are generated mostly automatically, how they
                 are applied using dynamic-linking technology, and how
                 code is compiled to make it updateable. To concretely
                 illustrate our system, we have implemented a
                 dynamically updateable web server, FlashEd. We discuss
                 our experience building and maintaining FlashEd, and
                 generalize to present observations about updateable
                 software development. Performance experiments show that
                 for FlashEd, the overhead due to updating is low:
                 typically less than 1 percent.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barabash:2005:PIM,
  author =       "Katherine Barabash and Ori Ben-Yitzhak and Irit Goft
                 and Elliot K. Kolodner and Victor Leikehman and Yoav
                 Ossia and Avi Owshanko and Erez Petrank",
  title =        "A parallel, incremental, mostly concurrent garbage
                 collector for servers",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1097--1146",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108972",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Multithreaded applications with multigigabyte heaps
                 running on modern servers provide new challenges for
                 garbage collection (GC). The challenges for
                 ``server-oriented'' GC include: ensuring short pause
                 times on a multigigabyte heap while minimizing
                 throughput penalty, good scaling on multiprocessor
                 hardware, and keeping the number of expensive
                 multicycle fence instructions required by weak ordering
                 to a minimum. We designed and implemented a collector
                 facing these demands building on the mostly concurrent
                 garbage collector proposed by Boehm et al. [1991]. Our
                 collector incorporates new ideas into the original
                 collector. We make it parallel and incremental; we
                 employ concurrent low-priority background GC threads to
                 take advantage of processor idle time; we propose novel
                 algorithmic improvements to the basic mostly concurrent
                 algorithm improving its efficiency and shortening its
                 pause times; and finally, we use advanced techniques,
                 such as a low-overhead work packet mechanism to enable
                 full parallelism among the incremental and concurrent
                 collecting threads and ensure load balancing. We
                 compared the new collector to the mature,
                 well-optimized, parallel, stop-the-world mark-sweep
                 collector already in the IBM JVM. When allowed to run
                 aggressively, using 72\% of the CPU utilization during
                 a short concurrent phase, our collector prototype
                 reduces the maximum pause time from 161 ms to 46 ms
                 while only losing 11.5\% throughput when running the
                 SPECjbb2000 benchmark on a 600-MB heap on an 8-way
                 PowerPC 1.1-GHz processors. When the collector is
                 limited to a nonintrusive operation using only 29\% of
                 the CPU utilization, the maximum pause time obtained is
                 79 ms and the loss in throughput is 15.4\%.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Glenstrup:2005:TAS,
  author =       "Arne John Glenstrup and Neil D. Jones",
  title =        "Termination analysis and specialization-point
                 insertion in offline partial evaluation",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1147--1215",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108973",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Recent research suggests that the goal of fully
                 automatic and reliable program generation for a broad
                 range of applications is coming nearer to feasibility.
                 However, several interesting and challenging problems
                 remain to be solved before it becomes a reality.
                 Solving them is also necessary, if we hope ever to
                 elevate software engineering from its current state (a
                 highly developed handiwork) into a successful branch of
                 engineering, capable of solving a wide range of new
                 problems by systematic, well-automated and well-founded
                 methods. A key problem in all program generation is
                 termination of the generation process. This article
                 focuses on off-line partial evaluation and describes
                 recent progress towards automatically solving the
                 termination problem, first for individual programs, and
                 then for specializers and ``generating extensions,''
                 the program generators that most offline partial
                 evaluators produce. The technique is based on
                 size-change graphs that approximate the changes in
                 parameter sizes at function calls. We formulate a
                 criterion, bounded anchoring, for detecting parameters
                 known to be bounded during specialization: a bounded
                 parameter can act as an anchor for other parameters.
                 Specialization points necessary for termination are
                 computed by adding a parameter that tracks call depth,
                 and then selecting a specialization point in every call
                 loop where it is unanchored. By generalizing all
                 unbounded parameters, we compute a binding-time
                 division which together with the set of specialization
                 points guarantees termination. Contributions of this
                 article include a proof, based on the operational
                 semantics of partial evaluation with memoization, that
                 the analysis guarantees termination; and an in-depth
                 description of safety of the increasing size
                 approximation operator required for termination
                 analysis in partial evaluation. Initial experiments
                 with a prototype shows that the analysis overall yields
                 binding-time divisions that can achieve a high degree
                 of specialization, while still guaranteeing
                 termination. The article ends with a list of
                 challenging problems whose solution would bring the
                 community closer to the goal of broad-spectrum, fully
                 automatic and reliable program generation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Stuckey:2005:TO,
  author =       "Peter J. Stuckey and Martin Sulzmann",
  title =        "A theory of overloading",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1216--1269",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108974",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a novel approach to allow for overloading
                 of identifiers in the spirit of type classes. Our
                 approach relies on a combination of the HM(X) type
                 system framework with Constraint Handling Rules (CHRs).
                 CHRs are a declarative language for writing incremental
                 constraint solvers, that provide our scheme with a form
                 of programmable type language. CHRs allow us to
                 precisely describe the relationships among overloaded
                 identifiers. Under some sufficient conditions on the
                 CHRs we achieve decidable type inference and the
                 semantic meaning of programs is unambiguous. Our
                 approach provides a common formal basis for many type
                 class extensions such as multiparameter type classes
                 and functional dependencies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Buhr:2005:ISM,
  author =       "Peter A. Buhr and Ashif S. Harji",
  title =        "Implicit-signal monitors",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1270--1343",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108975",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "An implicit (automatic) signal monitor uses a
                 waituntil predicate statement to construct
                 synchronization, as opposed to an explicit-signal
                 monitor using condition variables and signal/wait
                 statements for synchronization. Of the two
                 synchronization approaches, the implicit-signal monitor
                 is often easier to use and prove correct, but has an
                 inherently high execution cost. Hence, its primary use
                 is for prototyping concurrent systems using monitors,
                 where speed and accuracy of software development
                 override execution performance. After a concurrent
                 system is working, any implicit-signal monitor that is
                 a performance bottleneck can be converted to an
                 explicit-signal monitor. Unfortunately, many
                 monitor-based concurrency systems provide only
                 explicit-signal monitors, precluding the design
                 benefits of implicit-signal monitors. This article
                 presents a historical look at the development of the
                 implicit-signal monitor in relation to its counterpart
                 the explicit-signal monitor. An analysis of the
                 different kinds of implicit-signal monitors shows the
                 effects certain design decisions have on the problems
                 that can be solved and the performance of the
                 solutions. Finally, an extensive discussion is
                 presented on simulating an implicit-signal monitor via
                 different explicit-signal monitors. These simulations
                 are reasonably complex, depending on the kind of
                 explicit-signal monitor available for the simulation
                 and the desired semantics required for the
                 implicit-signal monitor. Interestingly, the complexity
                 of the simulations also illustrates certain
                 deficiencies with explicit-signal monitors, which are
                 discussed in detail. Performance comparisons are made
                 among the different simulations with monitors from the
                 concurrent systems PThreads, Java, and $ \mu $C++.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moreau:2005:BDR,
  author =       "Luc Moreau and Peter Dickman and Richard Jones",
  title =        "{Birrell}'s distributed reference listing revisited",
  journal =      j-TOPLAS,
  volume =       "27",
  number =       "6",
  pages =        "1344--1395",
  month =        nov,
  year =         "2005",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1108970.1108976",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 05:23:15 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The Java RMI collector is arguably the most widely
                 used distributed garbage collector. Its distributed
                 reference listing algorithm was introduced by Birrell
                 et al. in the context of Network Objects, where the
                 description was informal and heavily biased toward
                 implementation. In this article, we formalize this
                 algorithm in an implementation-independent manner,
                 which allows us to clarify weaknesses of the initial
                 presentation. In particular, we discover cases critical
                 to the correctness of the algorithm that were not
                 accounted for by Birrell. We use our formalization to
                 derive an invariant-based proof of correctness of the
                 algorithm that avoids notoriously difficult temporal
                 reasoning. Furthermore, we offer a novel graphical
                 representation of the state transition diagram, which
                 we use to provide intuitive explanations of the
                 algorithm and to investigate its tolerance to faults in
                 a systematic manner. Finally, we examine how the
                 algorithm may be optimized, either by placing
                 constraints on message channels or by tightening the
                 coupling between the application program and
                 distributed garbage collector.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Levanoni:2006:FRC,
  author =       "Yossi Levanoni and Erez Petrank",
  title =        "An on-the-fly reference-counting garbage collector for
                 {Java}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "1",
  pages =        "1--69",
  month =        jan,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1111596.1111597",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 24 05:55:31 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Reference-counting is traditionally considered
                 unsuitable for multiprocessor systems. According to
                 conventional wisdom, the update of reference slots and
                 reference-counts requires atomic or synchronized
                 operations. In this work we demonstrate this is not the
                 case by presenting a novel reference-counting algorithm
                 suitable for a multiprocessor system that does not
                 require any synchronized operation in its write barrier
                 (not even a compare-and-swap type of synchronization).
                 A second novelty of this algorithm is that it allows
                 eliminating a large fraction of the reference count
                 updates, thus, drastically reducing the
                 reference-counting traditional overhead. This article
                 includes a full proof of the algorithm showing that it
                 is safe (does not reclaim live objects) and live
                 (eventually reclaims all unreachable objects).\par

                 We have implemented our algorithm on Sun Microsystems'
                 Java Virtual Machine (JVM) 1.2.2 and ran it on a
                 four-way IBM Netfinity 8500R server with 550-MHz Intel
                 Pentium III Xeon and 2 GB of physical memory. Our
                 results show that the algorithm has an extremely low
                 latency and throughput that is comparable to the
                 stop-the-world mark and sweep algorithm used in the
                 original JVM",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ogasawara:2006:EED,
  author =       "Takeshi Ogasawara and Hideaki Komatsu and Toshio
                 Nakatani",
  title =        "{EDO}: {Exception-Directed Optimization} in {Java}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "1",
  pages =        "70--105",
  month =        jan,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1111596.1111598",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 24 05:55:31 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Optimizing exception handling is critical for programs
                 that frequently throw exceptions. We observed that
                 there are many such exception-intensive programs
                 written in Java. There are two commonly used exception
                 handling techniques, stack unwinding and stack cutting.
                 Stack unwinding optimizes the normal path by leaving
                 the exception handling path unoptimized, while stack
                 cutting optimizes the exception handling path by adding
                 extra work to the normal path. However, there has been
                 no single exception handling technique to optimize the
                 exception handling path without incurring any overhead
                 to the normal path.We propose a new technique called
                 {\em Exception-Directed Optimization\/} (EDO) that
                 optimizes exception-intensive programs without slowing
                 down exception-minimal programs. It is a
                 feedback-directed dynamic optimization consisting of
                 three steps: exception path profiling, exception path
                 inlining, and throw elimination. Exception path
                 profiling attempts to detect hot exception paths.
                 Exception path inlining embeds every hot exception path
                 into the corresponding catching method. Throw
                 elimination replaces a throw with a branch to the
                 corresponding handler. We implemented EDO in IBM's
                 production Just-in-Time compiler and made several
                 experiments. In summary, it improved the performance of
                 exception-intensive programs by up to 18.3\% without
                 decreasing the performance of exception-minimal
                 programs for SPECjvm98. We also found an opportunity
                 for performance improvement using EDO in the startup of
                 a Java application server.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kawahito:2006:ESE,
  author =       "Motohiro Kawahito and Hideaki Komatsu and Toshio
                 Nakatani",
  title =        "Effective sign extension elimination for {Java}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "1",
  pages =        "106--133",
  month =        jan,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1111596.1111599",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 24 05:55:31 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Computer designs are shifting from 32-bit
                 architectures to 64-bit architectures, while most of
                 the programs available today are still designed for
                 32-bit architectures. Java, for example, specifies the
                 frequently used ``int'' as a 32-bit signed integer. If
                 such Java programs are executed on a 64-bit
                 architecture, many 32-bit signed integers must be
                 sign-extended to 64-bit signed integers for correct
                 operations. This causes serious performance overhead.
                 In this article, we present a fast and effective
                 algorithm for eliminating sign extensions. We
                 implemented this algorithm in the IBM Java Just-in-Time
                 (JIT) compiler for IA-64. Our experimental results show
                 that our algorithm effectively eliminates the majority
                 of sign extensions. They also show that it improves
                 performance by 6.9\% for jBYTEmark and 3.3\% for
                 SPECjvm98 over the previously known best algorithm,
                 while it increases JIT compilation time by only
                 0.11\%.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Suganuma:2006:RBC,
  author =       "Toshio Suganuma and Toshiaki Yasue and Toshio
                 Nakatani",
  title =        "A region-based compilation technique for dynamic
                 compilers",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "1",
  pages =        "134--174",
  month =        jan,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1111596.1111600",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 24 05:55:31 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Method inlining and data flow analysis are two major
                 optimization components for effective program
                 transformations, but they often suffer from the
                 existence of rarely or never executed code contained in
                 the target method. One major problem lies in the
                 assumption that the compilation unit is partitioned at
                 method boundaries. This article describes the design
                 and implementation of a region-based compilation
                 technique in our dynamic optimization framework, in
                 which the compiled regions are selected as code
                 portions without rarely executed code. The key parts of
                 this technique are the region selection, partial
                 inlining, and region exit handling. For region
                 selection, we employ both static heuristics and dynamic
                 profiles to identify and eliminate rare sections of
                 code. The region selection process and method inlining
                 decisions are interwoven, so that method inlining
                 exposes other targets for region selection, while the
                 region selection in the inline target conserves the
                 inlining budget, allowing more method inlining to be
                 performed. The inlining process can be performed for
                 parts of a method, not just for the entire body of the
                 method. When the program attempts to exit from a region
                 boundary, we trigger recompilation and then use
                 on-stack replacement to continue the execution from the
                 corresponding entry point in the recompiled code. We
                 have implemented these techniques in our Java JIT
                 compiler, and conducted a comprehensive evaluation. The
                 experimental results show that our region-based
                 compilation approach achieves approximately 4\%
                 performance improvement on average, while reducing the
                 compilation overhead by 10\% to 30\%, in comparison to
                 the traditional method-based compilation techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hamlen:2006:CCE,
  author =       "Kevin W. Hamlen and Greg Morrisett and Fred B.
                 Schneider",
  title =        "Computability classes for enforcement mechanisms",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "1",
  pages =        "175--205",
  month =        jan,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1111596.1111601",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 24 05:55:31 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A precise characterization of those security policies
                 enforceable by program rewriting is given. This also
                 exposes and rectifies problems in prior work, yielding
                 a better characterization of those security policies
                 enforceable by execution monitors as well as a taxonomy
                 of enforceable security policies. Some but not all
                 classes can be identified with known classes from
                 computational complexity theory.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Abadi:2006:TSL,
  author =       "Martin Abadi and Cormac Flanagan and Stephen N.
                 Freund",
  title =        "Types for safe locking: {Static} race detection for
                 {Java}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "2",
  pages =        "207--255",
  month =        mar,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1119479.1119480",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 10 18:46:58 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article presents a static race-detection analysis
                 for multithreaded shared-memory programs, focusing on
                 the Java programming language. The analysis is based on
                 a type system that captures many common synchronization
                 patterns. It supports classes with internal
                 synchronization, classes that require client-side
                 synchronization, and thread-local classes. In order to
                 demonstrate the effectiveness of the type system, we
                 have implemented it in a checker and applied it to over
                 40,000 lines of hand-annotated Java code. We found a
                 number of race conditions in the standard Java
                 libraries and other test programs. The checker required
                 fewer than 20 additional type annotations per 1,000
                 lines of code. This article also describes two
                 improvements that facilitate checking much larger
                 programs: an algorithm for annotation inference and a
                 user interface that clarifies warnings generated by the
                 checker. These extensions have enabled us to use the
                 checker for identifying race conditions in large-scale
                 software systems with up to 500,000 lines of code.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Payet:2006:NIL,
  author =       "Etienne Payet and Fred Mesnard",
  title =        "Nontermination inference of logic programs",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "2",
  pages =        "256--289",
  month =        mar,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1119479.1119481",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 10 18:46:58 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a static analysis technique for
                 nontermination inference of logic programs. Our
                 framework relies on an extension of the subsumption
                 test, where some specific argument positions can be
                 instantiated while others are generalized. We give
                 syntactic criteria to statically identify such argument
                 positions from the text of a program. Atomic left
                 looping queries are generated bottom-up from selected
                 subsets of the binary unfoldings of the program of
                 interest. We propose a set of correct algorithms for
                 automating the approach. Then, nontermination inference
                 is tailored to attempt proofs of optimality of left
                 termination conditions computed by a termination
                 inference tool. An experimental evaluation is reported
                 and the analyzers can be tried online at
                 \path=http://www.univ-reunion.fr/~gcc=. When
                 termination and nontermination analysis produce
                 complementary results for a logic procedure, then with
                 respect to the leftmost selection rule and the language
                 used to describe sets of atomic queries, each analysis
                 is optimal and together, they induce a characterization
                 of the operational behavior of the logic procedure.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Merro:2006:BBS,
  author =       "Massimo Merro and Matthew Hennessy",
  title =        "A bisimulation-based semantic theory of {Safe
                 Ambients}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "2",
  pages =        "290--330",
  month =        mar,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1119479.1119482",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 10 18:46:58 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We develop a semantics theory for SAP, a variant of
                 Levi and Sangiorgi's Safe Ambients, SA. The dynamics of
                 SA relies upon capabilities (and co-capabilities)
                 exercised by mobile agents, called ambients, to
                 interact with each other. These capabilities contain
                 references, the names of ambients with which they wish
                 to interact. In SAP we generalize the notion of
                 capability: in order to interact with an ambient $n$,
                 an ambient $m$ must exercise a capability indicating
                 both $n$ and a password $h$ to access $n$; the
                 interaction between $n$ and $m$ takes place only if $n$
                 is willing to perform a corresponding co-capability
                 with the same password $h$. The name $h$ can also be
                 looked upon as a port to access ambient $n$ via port
                 $h$. In SAP, by managing passwords/ports, for example
                 generating new ones and distributing them selectively,
                 an ambient may now program who may migrate into its
                 computation space, and when. Moreover in SAP, an
                 ambient may provide different services/resources
                 depending on the port accessed by the incoming clients.
                 Then we give an lts-based operational semantics for SAP
                 and a labelled bisimulation equivalence, which is
                 proved to coincide with reduction barbed congruence. We
                 use our notion of bisimulation to prove a set of
                 algebraic laws that are subsequently exploited to prove
                 more significant examples.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ducasse:2006:TMF,
  author =       "St{\'e}phane Ducasse and Oscar Nierstrasz and
                 Nathanael Sch{\"a}rli and Roel Wuyts and Andrew P.
                 Black",
  title =        "Traits: a mechanism for fine-grained reuse",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "2",
  pages =        "331--388",
  month =        mar,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1119479.1119483",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 10 18:46:58 MST 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Inheritance is well-known and accepted as a mechanism
                 for reuse in object-oriented languages. Unfortunately,
                 due to the coarse granularity of inheritance, it may be
                 difficult to decompose an application into an optimal
                 class hierarchy that maximizes software reuse. Existing
                 schemes based on single inheritance, multiple
                 inheritance, or mixins, all pose numerous problems for
                 reuse. To overcome these problems we propose traits,
                 pure units of reuse consisting only of methods. We
                 develop a formal model of traits that establishes how
                 traits can be composed, either to form other traits, or
                 to form classes. We also outline an experimental
                 validation in which we apply traits to refactor a
                 nontrivial application into composable units.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Vansummeren:2006:TIU,
  author =       "Stijn Vansummeren",
  title =        "Type inference for unique pattern matching",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "3",
  pages =        "389--428",
  month =        may,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1133651.1133652",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 30 16:33:23 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/string-matching.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Regular expression patterns provide a natural,
                 declarative way to express constraints on
                 semistructured data and to extract relevant information
                 from it. Indeed, it is a core feature of the
                 programming language Perl, surfaces in various UNIX
                 tools such as sed and awk, and has recently been
                 proposed in the context of the XML programming language
                 XDuce. Since regular expressions can be ambiguous in
                 general, different disambiguation policies have been
                 proposed to get a unique matching strategy. We formally
                 define the matching semantics under both (1) the POSIX,
                 and (2) the first and longest match disambiguation
                 strategies. We show that the generally accepted method
                 of defining the longest match in terms of the first
                 match and recursion does not conform to the natural
                 notion of longest match. We continue by solving the
                 type inference problem for both disambiguation
                 strategies, which consists of calculating the set of
                 all subparts of input values a subexpression can match
                 under the given policy.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grossman:2006:QTI,
  author =       "Dan Grossman",
  title =        "Quantified types in an imperative language",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "3",
  pages =        "429--475",
  month =        may,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1133651.1133653",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 30 16:33:23 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We describe universal types, existential types, and
                 type constructors in Cyclone, a strongly typed C-like
                 language. We show how the language naturally supports
                 first-class polymorphism and polymorphic recursion
                 while requiring an acceptable amount of explicit type
                 information. More importantly, we consider the
                 soundness of type variables in the presence of C-style
                 mutation and the address-of operator. For polymorphic
                 references, we describe a solution more natural for the
                 C level than the ML-style ``value restriction.'' For
                 existential types, we discover and subsequently avoid a
                 subtle unsoundness issue resulting from the address-of
                 operator. We develop a formal abstract machine and
                 type-safety proof that capture the essence of type
                 variables at the C level.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hertz:2006:GOL,
  author =       "Matthew Hertz and Stephen M. Blackburn and J. Eliot B.
                 Moss and Kathryn S. McKinley and Darko Stefanovi{\'c}",
  title =        "Generating object lifetime traces with {Merlin}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "3",
  pages =        "476--516",
  month =        may,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1133651.1133654",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 30 16:33:23 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Programmers are writing a rapidly growing number of
                 programs in object-oriented languages, such as Java and
                 C\#, that require garbage collection. Garbage
                 collection traces and simulation speed up research by
                 enabling deeper understandings of object lifetime
                 behavior and quick exploration and design of new
                 garbage collection algorithms. When generating perfect
                 traces, the brute-force method of computing object
                 lifetimes requires a whole-heap garbage collection at
                 every potential collection point in the program.
                 Because this process is prohibitively expensive,
                 researchers often use granulated traces by collecting
                 only periodically, for example, every 32 KB of
                 allocation. We extend the state of the art for
                 simulating garbage collection algorithms in two ways.
                 First, we develop a systematic methodology for
                 simulation studies of copying garbage collection and
                 present results showing the effects of trace
                 granularity on these simulations. We show that trace
                 granularity often distorts simulated garbage collection
                 results compared with perfect traces. Second, we
                 present and measure the performance of a new algorithm
                 called Merlin for computing object lifetimes. Merlin
                 timestamps objects and later uses the timestamps of
                 dead objects to reconstruct when they died. The Merlin
                 algorithm piggybacks on garbage collections performed
                 by the base system. Experimental results show that
                 Merlin can generate traces over two orders of magnitude
                 faster than the brute-force method which collects after
                 every object allocation. We also use Merlin to produce
                 visualizations of heap behavior that expose new object
                 lifetime behaviors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Clifton:2006:MDR,
  author =       "Curtis Clifton and Todd Millstein and Gary T. Leavens
                 and Craig Chambers",
  title =        "{MultiJava}: {Design} rationale, compiler
                 implementation, and applications",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "3",
  pages =        "517--575",
  month =        may,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1133651.1133655",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue May 30 16:33:23 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "MultiJava is a conservative extension of the Java
                 programming language that adds symmetric multiple
                 dispatch and open classes. Among other benefits,
                 multiple dispatch provides a solution to the binary
                 method problem. Open classes provide a solution to the
                 extensibility problem of object-oriented programming
                 languages, allowing the modular addition of both new
                 types and new operations to an existing type hierarchy.
                 This article illustrates and motivates the design of
                 MultiJava and describes its modular static typechecking
                 and modular compilation strategies. Although MultiJava
                 extends Java, the key ideas of the language design are
                 applicable to other object-oriented languages, such as
                 C\# and C++, and even, with some modifications, to
                 functional languages such as ML. This article also
                 discusses the variety of application domains in which
                 MultiJava has been successfully used by others,
                 including pervasive computing, graphical user
                 interfaces, and compilers. MultiJava allows users to
                 express desired programming idioms in a way that is
                 declarative and supports static typechecking, in
                 contrast to the tedious and type-unsafe workarounds
                 required in Java. MultiJava also provides opportunities
                 for new kinds of extensibility that are not easily
                 available in Java.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Scott:2006:RNG,
  author =       "Elizabeth Scott and Adrian Johnstone",
  title =        "Right nulled {GLR} parsers",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "4",
  pages =        "577--618",
  month =        jul,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1146809.1146810",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Aug 23 15:21:57 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The right nulled generalized LR parsing algorithm is a
                 new generalization of LR parsing which provides an
                 elegant correction to, and extension of, Tomita's GLR
                 methods whereby we extend the notion of a reduction in
                 a shift-reduce parser to include right nulled items.
                 The result is a parsing technique which runs in linear
                 time on LR(1) grammars and whose performance degrades
                 gracefully to a polynomial bound in the presence of
                 nonLR(1) rules. Compared to other GLR-based techniques,
                 our algorithm is simpler and faster.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Klein:2006:MCM,
  author =       "Gerwin Klein and Tobias Nipkow",
  title =        "A machine-checked model for a {Java-like} language,
                 virtual machine, and compiler",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "4",
  pages =        "619--695",
  month =        jul,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1146809.1146811",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Aug 23 15:21:57 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We introduce Jinja, a Java-like programming language
                 with a formal semantics designed to exhibit core
                 features of the Java language architecture. Jinja is a
                 compromise between the realism of the language and the
                 tractability and clarity of its formal semantics. The
                 following aspects are formalised: a big and a small
                 step operational semantics for Jinja and a proof of
                 their equivalence, a type system and a definite
                 initialisation analysis, a type safety proof of the
                 small step semantics, a virtual machine (JVM), its
                 operational semantics and its type system, a type
                 safety proof for the JVM; a bytecode verifier, that is,
                 a data flow analyser for the JVM, a correctness proof
                 of the bytecode verifier with respect to the type
                 system, and a compiler and a proof that it preserves
                 semantics and well-typedness. The emphasis of this work
                 is not on particular language features but on providing
                 a unified model of the source language, the virtual
                 machine, and the compiler. The whole development has
                 been carried out in the theorem prover Isabelle/HOL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ager:2006:FPE,
  author =       "Mads Sig Ager and Olivier Danvy and Henning Korsholm
                 Rohde",
  title =        "Fast partial evaluation of pattern matching in
                 strings",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "4",
  pages =        "696--714",
  month =        jul,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1146809.1146812",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Aug 23 15:21:57 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We show how to obtain all of Knuth, Morris, and
                 Pratt's linear-time string matcher by specializing a
                 quadratic-time string matcher with respect to a pattern
                 string. Although it has been known for fifteen years
                 how to obtain this linear matcher by partial evaluation
                 of a quadratic one, how to obtain it in linear time has
                 remained an open problem. Obtaining a linear matcher by
                 the partial evaluation of a quadratic one is achieved
                 by performing its backtracking at specialization time
                 and memoizing its results. We show (1) how to rewrite
                 the source matcher such that its static intermediate
                 computations can be shared at specialization time and
                 (2) how to extend the memoization capabilities of a
                 partial evaluator to static functions. Such an extended
                 partial evaluator, if its memoization is implemented
                 efficiently, specializes the rewritten source matcher
                 in linear time. Finally, we show that the method also
                 applies to a variant of Boyer and Moore's string
                 matcher.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Carlsson:2006:MAC,
  author =       "Richard Carlsson and Konstantinos Sagonas and Jesper
                 Wilhelmsson",
  title =        "Message analysis for concurrent programs using message
                 passing",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "4",
  pages =        "715--746",
  month =        jul,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1146809.1146813",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Aug 23 15:21:57 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We describe an analysis-driven storage allocation
                 scheme for concurrent systems that use message passing
                 with copying semantics. The basic principle is that in
                 such a system, data which is not part of any message
                 does not need to be allocated in a shared data area.
                 This allows for the deallocation of thread-specific
                 data without requiring global synchronization and often
                 without even triggering garbage collection. On the
                 other hand, data that is part of a message should
                 preferably be allocated on a shared area since this
                 allows for fast (O(1)) interprocess communication that
                 does not require actual copying. In the context of a
                 dynamically typed, higher-order concurrent functional
                 language, we present a static message analysis which
                 guides the allocation. As shown by our performance
                 evaluation, conducted using a production-quality
                 language implementation, the analysis is effective
                 enough to discover most data which is to be used as a
                 message, and to allow the allocation scheme to combine
                 the best performance characteristics of both a
                 process-centric and a communal memory architecture.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Boute:2006:CSD,
  author =       "Raymond T. Boute",
  title =        "Calculational semantics: {Deriving} programming
                 theories from equations by functional predicate
                 calculus",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "4",
  pages =        "747--793",
  month =        jul,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1146809.1146814",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Aug 23 15:21:57 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The objects of programming semantics, namely, programs
                 and languages, are inherently formal, but the
                 derivation of semantic theories is all too often
                 informal, deprived of the benefits of formal
                 calculation ``guided by the shape of the formulas.''
                 Therefore, the main goal of this article is to provide
                 for the study of semantics an approach with the same
                 convenience and power of discovery that calculus has
                 given for many years to applied mathematics, physics,
                 and engineering. The approach uses functional predicate
                 calculus and concrete generic functionals; in fact, a
                 small part suffices. Application to a semantic theory
                 proceeds by describing program behavior in the simplest
                 possible way, namely by program equations, and
                 discovering the axioms of the theory as theorems by
                 calculation. This is shown in outline for a few
                 theories, and in detail for axiomatic semantics,
                 fulfilling a second goal of this article. Indeed, a
                 chafing problem with classical axiomatic semantics is
                 that some axioms are unintuitive at first, and that
                 justifications via denotational semantics are too
                 elaborate to be satisfactory. Derivation provides more
                 transparency. Calculation of formulas for ante- and
                 postconditions is shown in general, and for the major
                 language constructs in particular. A basic problem
                 reported in the literature, whereby relations are
                 inadequate for handling nondeterminacy and termination,
                 is solved here through appropriately defined program
                 equations. Several variants and an example in
                 mathematical analysis are also presented. One
                 conclusion is that formal calculation with quantifiers
                 is one of the most important elements for unifying
                 continuous and discrete mathematics in general, and
                 traditional engineering with computing science, in
                 particular.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Igarashi:2006:VPT,
  author =       "Atsushi Igarashi and Mirko Viroli",
  title =        "Variant parametric types: a flexible subtyping scheme
                 for generics",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "5",
  pages =        "795--847",
  month =        sep,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1152649.1152650",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 6 07:13:55 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We develop the mechanism of variant parametric types
                 as a means to enhance synergy between parametric and
                 inclusion polymorphism in object-oriented programming
                 languages. Variant parametric types are used to control
                 both the subtyping between different instantiations of
                 one generic class and the accessibility of their fields
                 and methods. On one hand, one parametric class can be
                 used to derive covariant types, contravariant types,
                 and bivariant types (generally called variant
                 parametric types) by attaching a variance annotation to
                 a type argument. On the other hand, the type system
                 prohibits certain method\slash field accesses,
                 according to variance annotations, when these accesses
                 may otherwise make the program unsafe. By exploiting
                 variant parametric types, a programmer can write
                 generic code abstractions that work on a wide range of
                 parametric types in a safe manner. For instance, a
                 method that only reads the elements of a container of
                 numbers can be easily modified so as to accept
                 containers of integers, floating-point numbers, or any
                 subtype of the number type. Technical subtleties in
                 typing for the proposed mechanism are addressed in
                 terms of an intuitive correspondence between variant
                 parametric and bounded existential types. Then, for a
                 rigorous argument of correctness of the proposed typing
                 rules, we extend Featherweight GJ---an existing formal
                 core calculus for Java with generics---with variant
                 parametric types and prove type soundness.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Joisha:2006:AAS,
  author =       "Pramod G. Joisha and Prithviraj Banerjee",
  title =        "An algebraic array shape inference system for
                 {MATLAB\reg{}}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "5",
  pages =        "848--907",
  month =        sep,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1152649.1152651",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 6 07:13:55 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The problem of inferring array shapes ahead of time in
                 languages that exhibit both implicit and dynamic typing
                 is a critical one because the ramifications of its
                 solution are the better organization of array storage
                 through compaction and reuse, and the generation of
                 high-performance code through specialization by shape.
                 This article addresses the problem in a prototypical
                 implicitly and dynamically typed array language called
                 MATLAB. The approach involves modeling the language's
                 shape semantics using an algebraic system, and applying
                 term rewriting techniques to evaluate expressions under
                 this algebra. Unlike prior efforts at array shape
                 determination, this enables the deduction of valuable
                 shape information even when array extents are
                 compile-time unknowns. Furthermore, unlike some
                 previous methods, our approach doesn't impose
                 monotonicity requirements on an operator's shape
                 semantics. The work also describes an inference
                 methodology and reports measurements from a type
                 inference engine called MAGICA. In a benchmark suite of
                 17 programs, the shape inference subsystem in MAGICA
                 detected the equivalence of over 61\% of the symbolic
                 shapes in six programs, and over 57\% and 37\% of the
                 symbolic shapes in two others. In the remaining nine
                 programs, all array shapes were inferred to be
                 compile-time constants.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Brecht:2006:CGC,
  author =       "Tim Brecht and Eshrat Arjomandi and Chang Li and Hang
                 Pham",
  title =        "Controlling garbage collection and heap growth to
                 reduce the execution time of {Java} applications",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "5",
  pages =        "908--941",
  month =        sep,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1152649.1152652",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 6 07:13:55 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In systems that support garbage collection, a tension
                 exists between collecting garbage too frequently and
                 not collecting it frequently enough. Garbage collection
                 that occurs too frequently may introduce unnecessary
                 overheads at the risk of not collecting much garbage
                 during each cycle. On the other hand, collecting
                 garbage too infrequently can result in applications
                 that execute with a large amount of virtual memory
                 (i.e., with a large footprint) and suffer from
                 increased execution times due to paging. In this
                 article, we use a large set of Java applications and
                 the highly tuned and widely used Boehm-Demers-Weiser
                 (BDW) conservative mark-and-sweep garbage collector to
                 experimentally examine the extent to which the
                 frequency of garbage collection impacts an
                 application's execution time, footprint, and pause
                 times. We use these results to devise some guidelines
                 for controlling garbage collection and heap growth in a
                 conservative garbage collector in order to minimize
                 application execution times. Then we describe new
                 strategies for controlling garbage collection and heap
                 growth that impact not only the frequency with which
                 garbage collection occurs but also the points at which
                 it occurs. Experimental results demonstrate that when
                 compared with the existing approach used in the
                 standard BDW collector, our new strategy can
                 significantly reduce application execution times. Our
                 goal is to obtain a better understanding of how to
                 control garbage collection and heap growth for an
                 individual application executing in isolation. These
                 results can be applied in a number of high-performance
                 computing and server environments, in addition to some
                 single-user environments. This work should also provide
                 insights into how to make better decisions that impact
                 garbage collection in multiprogrammed environments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kim:2006:ERI,
  author =       "Seon Wook Kim and Chong-Liang Ooi and Rudolf Eigenmann
                 and Babak Falsafi and T. N. Vijaykumar",
  title =        "Exploiting reference idempotency to reduce speculative
                 storage overflow",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "5",
  pages =        "942--965",
  month =        sep,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1152649.1152653",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 6 07:13:55 MDT 2006",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Recent proposals for multithreaded architectures
                 employ speculative execution to allow threads with
                 unknown dependences to execute speculatively in
                 parallel. The architectures use hardware speculative
                 storage to buffer speculative data, track data
                 dependences and correct incorrect executions through
                 roll-backs. Because all memory references access the
                 speculative storage, current proposals implement
                 speculative storage using small memory structures to
                 achieve fast access. The limited capacity of the
                 speculative storage causes considerable performance
                 loss due to speculative storage overflow whenever a
                 thread's speculative state exceeds the speculative
                 storage capacity. Larger threads exacerbate the
                 overflow problem but are preferable to smaller threads,
                 as larger threads uncover more parallelism. In this
                 article, we discover a new program property called
                 memory reference idempotency. Idempotent references are
                 guaranteed to be eventually corrected, though the
                 references may be temporarily incorrect in the process
                 of speculation. Therefore, idempotent references, even
                 from nonparallelizable program sections, need not be
                 tracked in the speculative storage, and instead can
                 directly access nonspeculative storage (i.e.,
                 conventional memory hierarchy). Thus, we reduce the
                 demand for speculative storage space in large threads.
                 We define a formal framework for reference idempotency
                 and present a novel compiler-assisted speculative
                 execution model. We prove the necessary and sufficient
                 conditions for reference idempotency using our model.
                 We present a compiler algorithm to label idempotent
                 memory references for the hardware. Experimental
                 results show that for our benchmarks, over 60\% of the
                 references in nonparallelizable program sections are
                 idempotent.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Joshi:2006:DPA,
  author =       "Rajeev Joshi and Greg Nelson and Yunhong Zhou",
  title =        "{Denali}: a practical algorithm for generating optimal
                 code",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "6",
  pages =        "967--989",
  month =        nov,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1186632.1186633",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:21 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Acar:2006:AFP,
  author =       "Umut A. Acar and Guy E. Blelloch and Robert Harper",
  title =        "Adaptive functional programming",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "6",
  pages =        "990--1034",
  month =        nov,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1186632.1186634",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:21 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Foster:2006:FIT,
  author =       "Jeffrey S. Foster and Robert Johnson and John Kodumal
                 and Alex Aiken",
  title =        "Flow-insensitive type qualifiers",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "6",
  pages =        "1035--1087",
  month =        nov,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1186632.1186635",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:21 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nanda:2006:ISM,
  author =       "Mangala Gowri Nanda and S. Ramesh",
  title =        "Interprocedural slicing of multithreaded programs with
                 applications to {Java}",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "6",
  pages =        "1088--1144",
  month =        nov,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1186632.1186636",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:21 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rosenkrantz:2006:MMA,
  author =       "Daniel J. Rosenkrantz and Lenore R. Mullin and Harry
                 B. {Hunt III}",
  title =        "On minimizing materializations of array-valued
                 temporaries",
  journal =      j-TOPLAS,
  volume =       "28",
  number =       "6",
  pages =        "1145--1177",
  month =        nov,
  year =         "2006",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1186632.1186637",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:21 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Simonet:2007:CBA,
  author =       "Vincent Simonet and Fran{\c{c}}ois Pottier",
  title =        "A constraint-based approach to guarded algebraic data
                 types",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "1:1--1:56",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180476",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Blackburn:2007:PBP,
  author =       "Stephen M. Blackburn and Matthew Hertz and Kathryn S.
                 Mckinley and J. Eliot B. Moss and Ting Yang",
  title =        "Profile-based pretenuring",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "2:1--2:57",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180477",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Pretenuring can reduce copying costs in garbage
                 collectors by allocating long-lived objects into
                 regions that the garbage collector will rarely, if
                 ever, collect. We extend previous work on pretenuring
                 as follows: (1) We produce pretenuring advice that is
                 neutral with respect to the garbage collector algorithm
                 and configuration. We thus can and do combine advice
                 from different applications. We find for our benchmarks
                 that predictions using object lifetimes at each
                 allocation site in Java programs are accurate, which
                 simplifies the pretenuring implementation. (2) We
                 gather and apply advice to both applications and Jikes
                 RVM, a compiler and runtime system for Java written in
                 Java. Our results demonstrate that building combined
                 advice into Jikes RVM from different application
                 executions improves performance, regardless of the
                 application Jikes RVM is compiling and executing. This
                 build-time advice thus gives user applications some
                 benefits of pretenuring, without any application
                 profiling. No previous work uses profile feedback to
                 pretenure in the runtime system. (3) We find that
                 application-only advice also consistently improves
                 performance, but that the combination of build-time and
                 application-specific advice is almost always noticeably
                 better. (4) Our same advice improves the performance of
                 generational, Older First, and Beltway collectors,
                 illustrating that it is collector neutral. (5) We
                 include an immortal allocation space in addition to a
                 nursery and older generation, and show that pretenuring
                 to immortal space has substantial benefit.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Drinic:2007:PPC,
  author =       "Milenko Drini{\'c} and Darko Kirovski and Hoi Vo",
  title =        "{PPMexe}: {Program} compression",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "3:1--3:31",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180478",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "With the emergence of software delivery platforms,
                 code compression has become an important system
                 component that strongly affects performance. This
                 article presents PPMexe, a compression mechanism for
                 program binaries that analyzes their syntax and
                 semantics to achieve superior compression ratios. We
                 use the generic paradigm of prediction by partial
                 matching (PPM) as the foundation of our compression
                 codec. PPMexe combines PPM with two preprocessing
                 steps: (i) instruction rescheduling to improve
                 prediction rates and (ii) heuristic partitioning of a
                 program binary into streams with high autocorrelation.
                 We improve the traditional PPM algorithm by (iii) using
                 an additional alphabet of frequent variable-length
                 supersymbols extracted from the input stream of
                 fixed-length symbols. In addition, PPMexe features (iv)
                 a low-overhead mechanism that enables decompression
                 starting from an arbitrary instruction of the
                 executable, a property pivotal for runtime software
                 delivery. We implemented PPMexe for x86 binaries and
                 tested it on several large applications. Binaries
                 compressed using PPMexe were 18--24\% smaller than
                 files created using off-the-shelf PPMD, one of the best
                 available compressors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Higuchi:2007:STS,
  author =       "Tomoyuki Higuchi and Atsushi Ohori",
  title =        "A static type system for {JVM} access control",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "4:1--4:42",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180479",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ben-Amram:2007:PTA,
  author =       "Amir M. Ben-Amram and Chin Soon Lee",
  title =        "Program termination analysis in polynomial time",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "5:1--5:37",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180480",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Eugster:2007:TBP,
  author =       "Patrick Eugster",
  title =        "Type-based publish\slash subscribe: {Concepts} and
                 experiences",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "1",
  pages =        "6:1--6:50",
  month =        jan,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1180475.1180481",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ward:2007:SPT,
  author =       "Martin Ward and Hussein Zedan",
  title =        "Slicing as a program transformation",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "7:1--7:53",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216375",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tardieu:2007:DLS,
  author =       "Olivier Tardieu",
  title =        "A deterministic logical semantics for pure {Esterel}",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "8:1--8:26",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216376",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Zhuang:2007:AAR,
  author =       "Xiaotong Zhuang and Santosh Pande",
  title =        "Allocating architected registers through differential
                 encoding",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "9:1--9:46",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216377",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bruynooghe:2007:TAL,
  author =       "Maurice Bruynooghe and Michael Codish and John P.
                 Gallagher and Samir Genaim and Wim Vanhoof",
  title =        "Termination analysis of logic programs through
                 combination of type-based norms",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "10:1--10:44",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216378",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hirzel:2007:FOP,
  author =       "Martin Hirzel and Daniel {Von Dincklage} and Amer
                 Diwan and Michael Hind",
  title =        "Fast online pointer analysis",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "11:1--11:55",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216379",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Marathe:2007:MMT,
  author =       "Jaydeep Marathe and Frank Mueller and Tushar Mohan and
                 Sally A. Mckee and Bronis R. {De Supinski} and Andy
                 Yoo",
  title =        "{METRIC}: {Memory} tracing via dynamic binary
                 rewriting to identify cache inefficiencies",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "12:1--12:36",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216380",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ancona:2007:PCT,
  author =       "D. Ancona and C. Anderson and F. Damiani and S.
                 Drossopoulou and P. Giannini and E. Zucca",
  title =        "A provenly correct translation of {Fickle} into
                 {Java}",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "2",
  pages =        "13:1--13:67",
  month =        apr,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1216374.1216381",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Apr 14 11:13:22 MDT 2007",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a translation from Fickle, a small
                 object-oriented language allowing objects to change
                 their class at runtime, into Java. The translation is
                 provenly correct in the sense that it preserves the
                 static and dynamic semantics. Moreover, it is
                 compatible with separate compilation, since the
                 translation of a Fickle class does not depend on the
                 implementation of used classes. Based on the formal
                 system, we have developed an implementation.

                 The translation turned out to be a more subtle problem
                 than we expected. In this article, we discuss four
                 possible approaches we considered for the design of the
                 translation and to justify our choice, we present
                 formally the translation and proof of preservation of
                 the static and dynamic semantics, and discuss the
                 prototype implementation. Moreover, we outline an
                 alternative translation based on generics that avoids
                 most of the casts (but not all) needed in the previous
                 translation.

                 The language Fickle has undergone and is still
                 undergoing several phases of development. In this
                 article we are discussing the translation of
                 Fickle$_{\rm II}$.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Abadi:2007:E,
  author =       "Mart{\'\i}n Abadi and Jens Palsberg",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "3",
  pages =        "14:1--14:1",
  month =        may,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1232420.1232421",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Podelski:2007:TPA,
  author =       "Andreas Podelski and Andrey Rybalchenko",
  title =        "Transition predicate abstraction and fair
                 termination",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "3",
  pages =        "15:1--15:31",
  month =        may,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1232420.1232422",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Xie:2007:SSF,
  author =       "Yichen Xie and Alex Aiken",
  title =        "{Saturn}: a scalable framework for error detection
                 using {Boolean} satisfiability",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "3",
  pages =        "16:1--16:43",
  month =        may,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1232420.1232423",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Foster:2007:CBT,
  author =       "J. Nathan Foster and Michael B. Greenwald and Jonathan
                 T. Moore and Benjamin C. Pierce and Alan Schmitt",
  title =        "Combinators for bidirectional tree transformations: a
                 linguistic approach to the view-update problem",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "3",
  pages =        "17:1--17:65",
  month =        may,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1232420.1232424",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lee:2007:DIE,
  author =       "Han B. Lee and Amer Diwan and J. Eliot B. Moss",
  title =        "Design, implementation, and evaluation of a
                 compilation server",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "4",
  pages =        "18:1--18:40",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1255450.1255451",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{DeSutter:2007:PID,
  author =       "Bjorn {De Sutter} and Ludo {Van Put} and Koen {De
                 Bosschere}",
  title =        "A practical interprocedural dominance algorithm",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "4",
  pages =        "19:1--19:44",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1255450.1255452",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Paz:2007:EFC,
  author =       "Harel Paz and David F. Bacon and Elliot K. Kolodner
                 and Erez Petrank and V. T. Rajan",
  title =        "An efficient on-the-fly cycle collection",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "4",
  pages =        "20:1--20:43",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1255450.1255453",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Moller:2007:SVX,
  author =       "Anders M{\o}ller and Mads {\O}sterby Olesen and
                 Michael I. Schwartzbach",
  title =        "Static validation of {XSL} transformations",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "4",
  pages =        "21:1--21:47",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1255450.1255454",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Stoyle:2007:MMS,
  author =       "Gareth Stoyle and Michael Hicks and Gavin Bierman and
                 Peter Sewell and Iulian Neamtiu",
  title =        "{{\em Mutatis Mutandis\/}}: {Safe} and predictable
                 dynamic software updating",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "4",
  pages =        "22:1--22:70",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1255450.1255455",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:39 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sagiv:2007:ISE,
  author =       "Mooly Sagiv",
  title =        "Introduction to special {ESOP'05} issue",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "23:1--23:2",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275498",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Biering:2007:BHH,
  author =       "Bodil Biering and Lars Birkedal and Noah Torp-Smith",
  title =        "{BI}-hyperdoctrines, higher-order separation logic,
                 and abstraction",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "24:1--24:35",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275499",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Fournet:2007:TDA,
  author =       "C{\'e}dric Fournet and Andrew D. Gordon and Sergio
                 Maffeis",
  title =        "A type discipline for authorization policies",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "25:1--25:37",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275500",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rival:2007:TPA,
  author =       "Xavier Rival and Laurent Mauborgne",
  title =        "The trace partitioning abstract domain",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "26:1--26:51",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275501",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ranganath:2007:NFC,
  author =       "Venkatesh Prasad Ranganath and Torben Amtoft and
                 Anindya Banerjee and John Hatcliff and Matthew B.
                 Dwyer",
  title =        "A new foundation for control dependence and slicing
                 for modern program structures",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "27:1--27:43",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275502",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chander:2007:ERB,
  author =       "Ajay Chander and David Espinosa and Nayeem Islam and
                 Peter Lee and George C. Necula",
  title =        "Enforcing resource bounds via static verification of
                 dynamic checks",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "28:1--28:18",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275503",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Muller-Olm:2007:AMA,
  author =       "Markus M{\"u}ller-Olm and Helmut Seidl",
  title =        "Analysis of modular arithmetic",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "5",
  pages =        "29:1--29:27",
  month =        aug,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1275497.1275504",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We consider integer arithmetic modulo a power of 2 as
                 provided by mainstream programming languages like Java
                 or standard implementations of C. The difficulty here
                 is that, for $ w > 1 $, the ring $ Z_m $ of integers
                 modulo $ m = 2^w $ has zero divisors and thus cannot be
                 embedded into a field. Not withstanding that, we
                 present intra- and interprocedural algorithms for
                 inferring for every program point u affine relations
                 between program variables valid at $u$. If conditional
                 branching is replaced with nondeterministic branching,
                 our algorithms are not only sound but also complete in
                 that they detect all valid affine relations in a
                 natural class of programs. Moreover, they run in time
                 linear in the program size and polynomial in the number
                 of program variables and can be implemented by using
                 the same modular integer arithmetic as the target
                 language to be analyzed. We also indicate how our
                 analysis can be extended to deal with equality guards,
                 even in an interprocedural setting.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{McKinley:2007:ECG,
  author =       "Kathryn S. McKinley and Keshav Pingali",
  title =        "Editorial: a changing of the guard",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "30:1--30:2",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1293892",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Honda:2007:UTS,
  author =       "Kohei Honda and Nobuko Yoshida",
  title =        "A uniform type structure for secure information flow",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "31:1--31:100",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286822",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grothoff:2007:EOC,
  author =       "Christian Grothoff and Jens Palsberg and Jan Vitek",
  title =        "Encapsulating objects with confined types",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "32:1--32:41",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286823",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Henzinger:2007:EMP,
  author =       "Thomas A. Henzinger and Christoph M. Kirsch",
  title =        "The embedded machine: {Predictable}, portable
                 real-time code",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "33:1--33:29",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286824",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The Embedded Machine is a virtual machine that
                 mediates in real time the interaction between software
                 processes and physical processes. It separates the
                 compilation of embedded programs into two phases. The
                 first phase, the platform-independent compiler phase,
                 generates E code (code executed by the Embedded
                 Machine), which supervises the timing, not the
                 scheduling of, application tasks relative to external
                 events such as clock ticks and sensor interrupts. E
                 code is portable and, given an input behavior, exhibits
                 predictable (i.e., deterministic) timing and output
                 behavior. The second phase, the platform-dependent
                 compiler phase, checks the time safety of the E code,
                 that is, whether platform performance (determined by
                 the hardware) and platform utilization (determined by
                 the scheduler of the operating system) enable its
                 timely execution. We have used the Embedded Machine to
                 compile and execute high-performance control
                 applications written in Giotto, such as the flight
                 control system of an autonomous model helicopter.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Thies:2007:STU,
  author =       "William Thies and Fr{\'e}d{\'e}ric Vivien and Saman
                 Amarasinghe",
  title =        "A step towards unifying schedule and storage
                 optimization",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "34:1--34:45",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286825",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Collberg:2007:DGB,
  author =       "Christian S. Collberg and Clark Thomborson and Gregg
                 M. Townsend",
  title =        "Dynamic graph-based software fingerprinting",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "35:1--35:67",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286826",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Fingerprinting embeds a secret message into a cover
                 message. In media fingerprinting, the secret is usually
                 a copyright notice and the cover a digital image.
                 Fingerprinting an object discourages intellectual
                 property theft, or when such theft has occurred, allows
                 us to prove ownership.\par

                 The Software Fingerprinting problem can be described as
                 follows. Embed a structure W into a program P such
                 that: W can be reliably located and extracted from P
                 even after P has been subjected to code transformations
                 such as translation, optimization and obfuscation; W is
                 stealthy; W has a high data rate; embedding W into P
                 does not adversely affect the performance of P; and W
                 has a mathematical property that allows us to argue
                 that its presence in P is the result of deliberate
                 actions.\par

                 In this article, we describe a software fingerprinting
                 technique in which a dynamic graph fingerprint is
                 stored in the execution state of a program. Because of
                 the hardness of pointer alias analysis such
                 fingerprints are difficult to attack automatically.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "35",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ohori:2007:PTM,
  author =       "Atsushi Ohori",
  title =        "A proof theory for machine code",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "36:1--36:35",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286827",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "36",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Casey:2007:OIB,
  author =       "Kevin Casey and M. Anton Ertl and David Gregg",
  title =        "Optimizing indirect branch prediction accuracy in
                 virtual machine interpreters",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "37:1--37:36",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286828",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "37",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Karkare:2007:IBC,
  author =       "Bageshri Karkare and Uday P. Khedker",
  title =        "An improved bound for call strings based
                 interprocedural analysis of bit vector frameworks",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "38:1--38:13",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286829",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "38",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Seo:2007:GDW,
  author =       "Sunae Seo and Hongseok Yang and Kwangkeun Yi and
                 Taisook Han",
  title =        "Goal-directed weakening of abstract interpretation
                 results",
  journal =      j-TOPLAS,
  volume =       "29",
  number =       "6",
  pages =        "39:1--39:39",
  month =        oct,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1286821.1286830",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:40 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "39",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Khedker:2007:HRA,
  author =       "Uday P. Khedker and Amitabha Sanyal and Amey Karkare",
  title =        "Heap reference analysis using access graphs",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "1:1--1:41",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290521",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Zhao:2007:FFS,
  author =       "Peng Zhao and Shimin Cui and Yaoqing Gao and Ra{\'u}l
                 Silvera and Jos{\'e} Nelson Amaral",
  title =        "{{\em Forma\/}}: a framework for safe automatic array
                 reshaping",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "2:1--2:30",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290522",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Binkley:2007:ESO,
  author =       "David Binkley and Mark Harman and Jens Krinke",
  title =        "Empirical study of optimization techniques for massive
                 slicing",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "3:1--3:33",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290523",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pearce:2007:EFS,
  author =       "David J. Pearce and Paul H. J. Kelly and Chris
                 Hankin",
  title =        "Efficient field-sensitive pointer analysis of {C}",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "4:1--4:42",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290524",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The subject of this article is flow- and
                 context-insensitive pointer analysis. We present a
                 novel approach for precisely modelling struct variables
                 and indirect function calls. Our method emphasizes
                 efficiency and simplicity and is based on a simple
                 language of set constraints. We obtain an $ O(v^4) $
                 bound on the time needed to solve a set of constraints
                 from this language, where $v$ is the number of
                 constraint variables. This gives, for the first time,
                 some insight into the hardness of performing
                 field-sensitive pointer analysis of C. Furthermore, we
                 experimentally evaluate the time versus precision
                 trade-off for our method by comparing against the
                 field-insensitive equivalent. Our benchmark suite
                 consists of 11 common C programs ranging in size from
                 15,000 to 200,000 lines of code. Our results indicate
                 the field-sensitive analysis is more expensive to
                 compute, but yields significantly better precision. In
                 addition, our technique has been integrated into the
                 latest release (version 4.1) of the GNU Compiler GCC.
                 Finally, we identify several previously unknown issues
                 with an alternative and less precise approach to
                 modelling struct variables, known as field-based
                 analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gil:2007:EDD,
  author =       "Joseph (Yossi) Gil and Yoav Zibin",
  title =        "Efficient dynamic dispatching with type slicing",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "5:1--5:53",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290525",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tse:2007:RTP,
  author =       "Stephen Tse and Steve Zdancewic",
  title =        "Run-time principals in information-flow type systems",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "1",
  pages =        "6:1--6:42",
  month =        nov,
  year =         "2007",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1290520.1290526",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:23:38 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pearlmutter:2008:RMA,
  author =       "Barak A. Pearlmutter and Jeffrey Mark Siskind",
  title =        "Reverse-mode {AD} in a functional framework: {Lambda}
                 the ultimate backpropagator",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "2",
  pages =        "7:1--7:36",
  month =        mar,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1330017.1330018",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:42 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Weimer:2008:ESP,
  author =       "Westley Weimer and George C. Necula",
  title =        "Exceptional situations and program reliability",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "2",
  pages =        "8:1--8:51",
  month =        mar,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1330017.1330019",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:42 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "It is difficult to write programs that behave
                 correctly in the presence of run-time errors. Proper
                 behavior in the face of exceptional situations is
                 important to the reliability of long-running programs.
                 Existing programming language features often provide
                 poor support for executing clean-up code and for
                 restoring invariants.\par

                 We present a data-flow analysis for finding a certain
                 class of exception-handling defects: those related to a
                 failure to release resources or to clean up properly
                 along all paths. Many real-world programs violate such
                 resource usage rules because of incorrect exception
                 handling. Our flow-sensitive analysis keeps track of
                 outstanding obligations along program paths and does a
                 precise modeling of control flow in the presence of
                 exceptions. Using it, we have found over 1,300
                 exception handling defects in over 5 million lines of
                 Java code.\par

                 Based on those defects we propose a programming
                 language feature, the compensation stack, that keeps
                 track of obligations at run time and ensures that they
                 are discharged. We present a type system for
                 compensation stacks that tracks collections of
                 obligations. Finally, we present case studies to
                 demonstrate that this feature is natural, efficient,
                 and can improve reliability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cooke:2008:NTD,
  author =       "Daniel E. Cooke and J. Nelson Rushton and Brad
                 Nemanich and Robert G. Watson and Per Andersen",
  title =        "Normalize, transpose, and distribute: an automatic
                 approach for handling nonscalars",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "2",
  pages =        "9:1--9:49",
  month =        mar,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1330017.1330020",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:42 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wang:2008:DSJ,
  author =       "Tao Wang and Abhik Roychoudhury",
  title =        "Dynamic slicing on {Java} bytecode traces",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "2",
  pages =        "10:1--10:49",
  month =        mar,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1330017.1330021",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:42 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liquori:2008:FME,
  author =       "Luigi Liquori and Arnaud Spiwack",
  title =        "{FeatherTrait}: a modest extension of {Featherweight
                 Java}",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "2",
  pages =        "11:1--11:32",
  month =        mar,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1330017.1330022",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:22:42 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Monniaux:2008:PVF,
  author =       "David Monniaux",
  title =        "The pitfalls of verifying floating-point
                 computations",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "12:1--12:41",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353446",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Current critical systems often use a lot of
                 floating-point computations, and thus the testing or
                 static analysis of programs containing floating-point
                 operators has become a priority. However, correctly
                 defining the semantics of common implementations of
                 floating-point is tricky, because semantics may change
                 according to many factors beyond source-code level,
                 such as choices made by compilers. We here give
                 concrete examples of problems that can appear and
                 solutions for implementing in analysis software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rinetzky:2008:CPF,
  author =       "N. Rinetzky and G. Ramalingam and M. Sagiv and E.
                 Yahav",
  title =        "On the complexity of partially-flow-sensitive alias
                 analysis",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "13:1--13:28",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353447",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dantas:2008:APA,
  author =       "Daniel S. Dantas and David Walker and Geoffrey
                 Washburn and Stephanie Weirich",
  title =        "{AspectML}: a polymorphic aspect-oriented functional
                 programming language",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "14:1--14:60",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353448",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Terauchi:2008:WSE,
  author =       "Tachio Terauchi and Alex Aiken",
  title =        "Witnessing side effects",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "15:1--15:42",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353449",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ben-Amram:2008:SCT,
  author =       "Amir M. Ben-Amram",
  title =        "Size-change termination with difference constraints",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "16:1--16:31",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353450",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pan:2008:PFE,
  author =       "Zhelong Pan and Rudolf Eigenmann",
  title =        "{PEAK} --- a fast and effective performance tuning
                 system via compiler optimization orchestration",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "3",
  pages =        "17:1--17:43",
  month =        may,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1353445.1353451",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jun 11 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Compile-time optimizations generally improve program
                 performance. Nevertheless, degradations caused by
                 individual compiler optimization techniques are to be
                 expected. Feedback-directed optimization orchestration
                 systems generate optimized code versions under a series
                 of optimization combinations, evaluate their
                 performance, and search for the best version. One
                 challenge to such systems is to tune program
                 performance quickly in an exponential search space.
                 Another challenge is to achieve high program
                 performance, considering that optimizations interact.
                 Aiming at these two goals, this article presents an
                 automated performance tuning system, PEAK, which
                 searches for the best compiler optimization
                 combinations for the important code sections in a
                 program. The major contributions made in this work are
                 as follows: (1) An algorithm called Combined
                 Elimination (CE) is developed to explore the
                 optimization space quickly and effectively; (2) Three
                 fast and accurate rating methods are designed to
                 evaluate the performance of an optimized code section
                 based on a partial execution of the program; (3) An
                 algorithm is developed to identify important code
                 sections as candidates for performance tuning by
                 trading off tuning speed and tuned program performance;
                 and (4) A set of compiler tools are implemented to
                 automate optimization orchestration. Orchestrating
                 optimization options in SUN Forte compilers at the
                 whole-program level, our CE algorithm improves
                 performance by 10.8\% over the SPEC CPU2000 FP baseline
                 setting, compared to 5.6\% improved by manual tuning.
                 Orchestrating GCC O3 optimizations, CE improves
                 performance by 12\% over O3, the highest optimization
                 level. Applying the rating methods, PEAK reduces tuning
                 time from 2.19 hours to 5.85 minutes on average, while
                 achieving equal or better program performance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Furr:2008:CTS,
  author =       "Michael Furr and Jeffrey S. Foster",
  title =        "Checking type safety of foreign function calls",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "18:1--18:63",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377493",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Foreign function interfaces (FFIs) allow components in
                 different languages to communicate directly with each
                 other. While FFIs are useful, they often require
                 writing tricky low-level code and include little or no
                 static safety checking, thus providing a rich source of
                 hard-to-find programming errors. In this article, we
                 study the problem of enforcing type safety across the
                 OCaml-to-C FFI and the Java Native Interface (JNI). We
                 present O-Saffire and J-Saffire, a pair of multilingual
                 type inference systems that ensure C code that uses
                 these FFIs accesses high-level data safely. Our
                 inference systems use {\em representational types\/} to
                 model C's low-level view of OCaml and Java values, and
                 singleton types to track integers, strings, memory
                 offsets, and type tags through C. J-Saffire, our Java
                 system, uses a polymorphic flow-insensitive,
                 unification-based analysis. Polymorphism is important
                 because it allows us to precisely model user-defined
                 wrapper functions and the more than 200 JNI functions.
                 O-Saffire, our OCaml system, uses a monomorphic
                 flow-sensitive analysis because, while polymorphism is
                 much less important for the OCaml FFI flow-sensitivity
                 is critical to track conditional branches, which are
                 used when pattern matching OCaml data in C. O-Saffire
                 also tracks garbage collection information to ensure
                 that local C pointers to the OCaml heap are registered
                 properly, which is not necessary for the JNI. We have
                 applied O-Saffire and J-Saffire to a set of benchmarks
                 and found many bugs and questionable coding practices.
                 These results suggest that static checking of FFIs can
                 be a valuable tool in writing correct multilingual
                 software.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dataflow analysis; FFI; flow-sensitive type system;
                 foreign function calls; Foreign function interface;
                 Java; Java Native Interface; JNI; multilingual type
                 inference; multilingual type system; OCaml;
                 representational type",
}

@Article{Lhotak:2008:RAB,
  author =       "Ond{\v{r}}ej Lhot{\'a}k and Laurie Hendren",
  title =        "Relations as an abstraction for {BDD}-based program
                 analysis",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "19:1--19:63",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377494",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article we present Jedd, a language extension
                 to Java that supports a convenient way of programming
                 with Binary Decision Diagrams (BDDs). The Jedd language
                 abstracts BDDs as database-style relations and
                 operations on relations, and provides static type rules
                 to ensure that relational operations are used
                 correctly.\par

                 The article provides a description of the Jedd language
                 and reports on the design and implementation of the
                 Jedd translator and associated runtime system. Of
                 particular interest is the approach to assigning
                 attributes from the high-level relations to physical
                 domains in the underlying BDDs, which is done by
                 expressing the constraints as a SAT problem and using a
                 modern SAT solver to compute the solution. Further, a
                 runtime system is defined that handles memory
                 management issues and supports a browsable profiling
                 tool for tuning the key BDD operations.\par

                 The motivation for designing Jedd was to support the
                 development of interrelated whole program analyses
                 based on BDDs. We have successfully used Jedd to build
                 Paddle, a framework of context-sensitive program
                 analyses, including points-to analysis and call graph
                 construction, as well as several client analyses.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Binary decision diagrams; Boolean formula
                 satisfiability; Java; language design; physical domain
                 assignment; points-to analysis; program analysis;
                 relations",
}

@Article{Flanagan:2008:TAS,
  author =       "Cormac Flanagan and Stephen N. Freund and Marina
                 Lifshin and Shaz Qadeer",
  title =        "Types for atomicity: {Static} checking and inference
                 for {Java}",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "20:1--20:52",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377495",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Atomicity is a fundamental correctness property in
                 multithreaded programs. A method is atomic if, for
                 every execution, there is an equivalent serial
                 execution in which the actions of the method are not
                 interleaved with actions of other threads. Atomic
                 methods are amenable to sequential reasoning, which
                 significantly facilitates subsequent analysis and
                 verification.\par

                 This article presents a type system for specifying and
                 verifying the atomicity of methods in multithreaded
                 Java programs using a synthesis of Lipton's theory of
                 reduction and type systems for race detection. The type
                 system supports guarded, write-guarded, and unguarded
                 fields, as well as thread-local data, parameterized
                 classes and methods, and protected locks. We also
                 present an algorithm for verifying atomicity via type
                 inference.\par

                 We have applied our type checker and type inference
                 tools to a number of commonly used Java library classes
                 and programs. These tools were able to verify the vast
                 majority of methods in these benchmarks as atomic,
                 indicating that atomicity is a widespread methodology
                 for multithreaded programming. In addition, reported
                 atomicity violations revealed some subtle errors in the
                 synchronization disciplines of these programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Atomicity; concurrent programs; type inference; type
                 systems",
}

@Article{Gal:2008:JBV,
  author =       "Andreas Gal and Christian W. Probst and Michael
                 Franz",
  title =        "{Java} bytecode verification via static single
                 assignment form",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "21:1--21:21",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377496",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Java Virtual Machines (JVMs) traditionally perform
                 bytecode verification by way of an iterative dataflow
                 analysis. Bytecode verification is necessary to ensure
                 type safety because temporary variables in the JVM are
                 not statically typed. We present an alternative
                 verification mechanism that transforms JVM bytecode
                 into Static Single Assignment Form (SSA) and thereby
                 propagates definitions directly to uses. Type checking
                 at control flow merge points can then be performed in a
                 single pass.\par

                 Our prototype implementation of the new algorithm is
                 faster than the standard JVM bytecode verifier. It has
                 the additional benefit of generating SSA as a side
                 effect, which may be immediately useful for a
                 subsequent dynamic compilation stage.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dataflow analysis; Java bytecode verification; static
                 single assignment form",
}

@Article{Bhatia:2008:RSE,
  author =       "Sapan Bhatia and Charles Consel and Calton Pu",
  title =        "Remote specialization for efficient embedded operating
                 systems",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "22:1--22:32",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377497",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Prior to their deployment on an embedded system,
                 operating systems are commonly tailored to reduce code
                 size and improve runtime performance. Program
                 specialization is a promising match for this process:
                 it is predictable and modules, and it allows the reuse
                 of previously implemented specializations. A
                 specialization engine for embedded systems must
                 overcome three main obstacles: (i) Reusing existing
                 compilers for embedded systems, (ii) supporting
                 specialization on a resource-limited system and (iii)
                 coping with dynamic applications by supporting
                 specialization on demand.\par

                 In this article, we describe a runtime specialization
                 infrastructure that addresses these problems. Our
                 solution proposes: (i) Specialization in two phases of
                 which the former generates specialized C templates and
                 the latter uses a dedicated compiler to generate
                 efficient native code. (ii) A virtualization mechanism
                 that facilitates specialization of code at a remote
                 location. (iii) An API and supporting OS extensions
                 that allow applications to produce, manage and dispose
                 of specialized code.\par

                 We evaluate our work through two case studies: (i) The
                 TCP/IP implementation of Linux and (ii) The TUX
                 embedded web server. We report appreciable improvements
                 in code size and performance. We also quantify the
                 overhead of specialization and argue that a
                 specialization server can scale to support a sizable
                 workload.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compilers; performance analysis; Remote
                 specialization; specialization server",
}

@Article{Rong:2008:RAS,
  author =       "Hongbo Rong and Alban Douillet and Guang R. Gao",
  title =        "Register allocation for software pipelined
                 multidimensional loops",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "23:1--23:68",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377498",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article investigates register allocation for
                 software pipelined multidimensional loops where the
                 execution of successive iterations from an
                 $n$-dimensional loop is overlapped. For single loop
                 software pipelining, the lifetimes of a loop variable
                 in successive iterations of the loop form a repetitive
                 pattern. An effective register allocation method is to
                 represent the pattern as a vector of lifetimes (or a
                 vector lifetime using Rau's terminology [Rau 1992]) and
                 map it to rotating registers. Unfortunately, the
                 software pipelined schedule of a multidimensional loop
                 is considerably more complex and so are the vector
                 lifetimes in it.\par

                 In this article, we develop a way to normalize and
                 represent the vector lifetimes, which captures their
                 complexity, while exposing their regularity that
                 enables a simple solution. The problem is formulated as
                 bin-packing of the multidimensional vector lifetimes on
                 the surface of a space-time cylinder. A metric, called
                 distance, is calculated either conservatively or
                 aggressively to guide the bin-packing process, so that
                 there is no overlapping between any two vector
                 lifetimes, and the register requirement is minimized.
                 This approach subsumes the classical register
                 allocation for software pipelined single loops as a
                 special case. The method has been implemented in the
                 ORC compiler and produced code for the IA-64
                 architecture. Experimental results show the
                 effectiveness. Several strategies for register
                 allocation are compared and analyzed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "register allocation; Software pipelining",
}

@Article{Torp-Smith:2008:LRA,
  author =       "Noah Torp-Smith and Lars Birkedal and John C.
                 Reynolds",
  title =        "Local reasoning about a copying garbage collector",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "4",
  pages =        "24:1--24:58",
  month =        jul,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1377492.1377499",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 5 19:14:53 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a programming language, model, and logic
                 appropriate for implementing and reasoning about a
                 memory management system. We state semantically what is
                 meant by correctness of a copying garbage collector,
                 and employ a variant of the novel separation logics to
                 formally specify partial correctness of Cheney's
                 copying garbage collector in our program logic.
                 Finally, we prove that our implementation of Cheney's
                 algorithm meets its specification using the logic we
                 have given and auxiliary variables.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "copying garbage collector; local reasoning; Separation
                 logic",
}

@Article{Preda:2008:SBA,
  author =       "Mila Dalla Preda and Mihai Christodorescu and Somesh
                 Jha and Saumya Debray",
  title =        "A semantics-based approach to malware detection",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "5",
  pages =        "25:1--25:54",
  month =        aug,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1387673.1387674",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 30 14:02:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Malware detection is a crucial aspect of software
                 security. Current malware detectors work by checking
                 for {\em signatures}, which attempt to capture the
                 syntactic characteristics of the machine-level byte
                 sequence of the malware. This reliance on a syntactic
                 approach makes current detectors vulnerable to code
                 obfuscations, increasingly used by malware writers,
                 that alter the syntactic properties of the malware byte
                 sequence without significantly affecting their
                 execution behavior.\par

                 This paper takes the position that the key to malware
                 identification lies in their semantics. It proposes a
                 semantics-based framework for reasoning about malware
                 detectors and proving properties such as soundness and
                 completeness of these detectors. Our approach uses a
                 trace semantics to characterize the behavior of malware
                 as well as that of the program being checked for
                 infection, and uses abstract interpretation to ``hide''
                 irrelevant aspects of these behaviors. As a concrete
                 application of our approach, we show that (1) standard
                 signature matching detection schemes are generally
                 sound but not complete, (2) the semantics-aware malware
                 detector proposed by Christodorescu et al. is complete
                 with respect to a number of common obfuscations used by
                 malware writers and (3) the malware detection scheme
                 proposed by Kinder et al. and based on standard
                 model-checking techniques is sound in general and
                 complete on some, but not all, obfuscations handled by
                 the semantics-aware malware detector.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract interpretation; Malware detection;
                 obfuscation; trace semantics",
}

@Article{Cheney:2008:NLP,
  author =       "James Cheney and Christian Urban",
  title =        "Nominal logic programming",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "5",
  pages =        "26:1--26:47",
  month =        aug,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1387673.1387675",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 30 14:02:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Nominal logic is an extension of first-order logic
                 which provides a simple foundation for formalizing and
                 reasoning about abstract syntax modulo consistent
                 renaming of bound names (that is, $ \alpha
                 $-equivalence). This article investigates logic
                 programming based on nominal logic. We describe some
                 typical nominal logic programs, and develop the
                 model-theoretic, proof-theoretic, and operational
                 semantics of such programs. Besides being of interest
                 for ensuring the correct behavior of implementations,
                 these results provide a rigorous foundation for
                 techniques for analysis and reasoning about nominal
                 logic programs, as we illustrate via examples.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "logic programming; name-binding; Nominal logic;
                 semantics",
}

@Article{Terauchi:2008:CCC,
  author =       "Tachio Terauchi and Alex Aiken",
  title =        "A capability calculus for concurrency and
                 determinism",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "5",
  pages =        "27:1--27:30",
  month =        aug,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1387673.1387676",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 30 14:02:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article presents a static system for checking
                 determinism (technically, partial confluence) of
                 communicating concurrent processes. Our approach
                 automatically detects partial confluence in programs
                 communicating via a mix of different kinds of
                 communication methods: rendezvous channels, buffered
                 channels, broadcast channels, and reference cells. Our
                 system reduces the partial confluence checking problem
                 in polynomial time (in the size of the program) to the
                 problem of solving a system of rational linear
                 inequalities, and is thus efficient.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "27",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "capabilities; Determinism; type systems",
}

@Article{Gil:2008:TDB,
  author =       "Joseph (Yossi) Gil and William Pugh and Grant E.
                 Weddell and Yoav Zibin",
  title =        "Two-dimensional bidirectional object layout",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "5",
  pages =        "28:1--28:38",
  month =        aug,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1387673.1387677",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 30 14:02:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Object layout schemes used in C++ and other languages
                 rely on (sometimes numerous) compiler generated fields.
                 We describe a language-independent object layout
                 scheme, which is space optimal, that is, objects are
                 contiguous, and contain {\em no compiler generated
                 fields\/} other than a single type identifier. As in
                 C++ and other multiple inheritance languages such as
                 CECIL and DYLAN, the new scheme sometimes requires
                 extra levels of indirection to access some of the
                 fields. Using a data set of 28 hierarchies, totaling
                 almost 50,000 types, we show that this scheme improves
                 field access efficiency over standard implementations,
                 and competes favorably with (the non-space-optimal)
                 highly optimized C++ specific implementations. The
                 benchmark includes an analytical model for computing
                 the frequency of indirections in a sequence of field
                 access operations. Our layout scheme relies on
                 whole-program analysis, which requires about 10
                 microseconds per type on a contemporary architecture
                 (Pentium III, 900MHz, 256MB machine), even in very
                 large hierarchies. We also present a layout scheme for
                 separate compilation using the user-annotation of {\em
                 virtual inheritance edge\/} that is used in C++.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "28",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "bidirectional; coloring; hierarchy; inheritance;
                 layout",
}

@Article{Naik:2008:TSE,
  author =       "Mayur Naik and Jens Palsberg",
  title =        "A type system equivalent to a model checker",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "5",
  pages =        "29:1--29:24",
  month =        aug,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1387673.1387678",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 30 14:02:55 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Type systems and model checking are two prevalent
                 approaches to program verification. A prominent
                 difference between them is that type systems are
                 typically defined in a syntactic and modular style
                 whereas model checking is usually performed in a
                 semantic and whole-program style. This difference
                 between the two approaches makes them complementary to
                 each other: type systems are good at explaining why a
                 program was accepted while model checkers are good at
                 explaining why a program was rejected.\par

                 We present a type system that is equivalent to a model
                 checker for verifying temporal safety properties of
                 imperative programs. The model checker is natural and
                 may be instantiated with any finite-state abstraction
                 scheme such as predicate abstraction. The type system,
                 which is also parametric, type checks exactly those
                 programs that are accepted by the model checker. It
                 uses a variant of function types to capture flow
                 sensitivity and intersection and union types to capture
                 context sensitivity. Our result sheds light on the
                 relationship between type systems and model checking,
                 provides a methodology for studying their relative
                 expressiveness, is a step towards sharing results
                 between the two approaches, and motivates synergistic
                 program analyses involving interplay between them.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "29",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Model checking; type systems",
}

@Article{Bhargavan:2008:VPB,
  author =       "Karthikeyan Bhargavan and C{\'e}dric Fournet and
                 Andrew D. Gordon",
  title =        "Verifying policy-based web services security",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "6",
  pages =        "30:1--30:59",
  month =        oct,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1391956.1391957",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 1 20:05:05 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "WS-SecurityPolicy is a declarative language for
                 configuring web services security mechanisms. We
                 describe a formal semantics for WS-SecurityPolicy and
                 propose a more abstract language for specifying secure
                 links between web services and their clients. We
                 present the architecture and implementation of tools
                 that (1) compile policy files from link specifications,
                 and (2) verify by invoking a theorem prover whether a
                 set of policy files run by any number of senders and
                 receivers correctly implements the goals of a link
                 specification, in spite of active attackers.
                 Policy-driven web services implementations are prone to
                 the usual subtle vulnerabilities associated with
                 cryptographic protocols; our tools help prevent such
                 vulnerabilities. We can verify policies when first
                 compiled from link specifications, and also re-verify
                 policies against their original goals after any
                 modifications during deployment. Moreover, we present
                 general security theorems for all configurations that
                 rely on compiled policies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "30",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "pi calculus; Web services; XML security",
}

@Article{Tratt:2008:DSL,
  author =       "Laurence Tratt",
  title =        "Domain specific language implementation via
                 compile-time meta-programming",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "6",
  pages =        "31:1--31:40",
  month =        oct,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1391956.1391958",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 1 20:05:05 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Domain specific languages (DSLs) are mini-languages
                 that are increasingly seen as being a valuable tool for
                 software developers and non-developers alike. DSLs must
                 currently be created in an ad-hoc fashion, often
                 leading to high development costs and implementations
                 of variable quality. In this article, I show how
                 expressive DSLs can be hygienically embedded in the
                 Converge programming language using its compile-time
                 meta-programming facility, the concept of DSL blocks,
                 and specialised error reporting techniques. By making
                 use of pre-existing facilities, and following a simple
                 methodology, DSL implementation costs can be
                 significantly reduced whilst leading to higher quality
                 DSL implementations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "31",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compile-time meta-programming; domain specific
                 languages; Syntax extension",
}

@Article{Arenaz:2008:XEF,
  author =       "Manuel Arenaz and Juan Touri{\~n}o and Ramon Doallo",
  title =        "{XARK}: an extensible framework for automatic
                 recognition of computational kernels",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "6",
  pages =        "32:1--32:56",
  month =        oct,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1391956.1391959",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 1 20:05:05 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The recognition of program constructs that are
                 frequently used by software developers is a powerful
                 mechanism for optimizing and parallelizing compilers to
                 improve the performance of the object code. The
                 development of techniques for automatic recognition of
                 computational kernels such as inductions, reductions
                 and array recurrences has been an intensive research
                 area in the scope of compiler technology during the
                 90's. This article presents a new compiler framework
                 that, unlike previous techniques that focus on specific
                 and isolated kernels, recognizes a comprehensive
                 collection of computational kernels that appear
                 frequently in full-scale real applications. The XARK
                 compiler operates on top of the Gated Single Assignment
                 (GSA) form of a high-level intermediate representation
                 (IR) of the source code. Recognition is carried out
                 through a demand-driven analysis of this high-level IR
                 at two different levels. First, the dependences between
                 the statements that compose the strongly connected
                 components (SCCs) of the data-dependence graph of the
                 GSA form are analyzed. As a result of this intra-SCC
                 analysis, the computational kernels corresponding to
                 the execution of the statements of the SCCs are
                 recognized. Second, the dependences between statements
                 of different SCCs are examined in order to recognize
                 more complex kernels that result from combining simpler
                 kernels in the same code. Overall, the XARK compiler
                 builds a hierarchical representation of the source code
                 as kernels and dependence relationships between those
                 kernels. This article describes in detail the
                 collection of computational kernels recognized by the
                 XARK compiler. Besides, the internals of the
                 recognition algorithms are presented. The design of the
                 algorithms enables to extend the recognition
                 capabilities of XARK to cope with new kernels, and
                 provides an advanced symbolic analysis framework to run
                 other compiler techniques on demand. Finally, extensive
                 experiments showing the effectiveness of XARK for a
                 collection of benchmarks from different application
                 domains are presented. In particular, the SparsKit-II
                 library for the manipulation of sparse matrices, the
                 Perfect benchmarks, the SPEC CPU2000 collection and the
                 PLTMG package for solving elliptic partial differential
                 equations are analyzed in detail.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "32",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Automatic kernel recognition; demand-driven
                 algorithms; gated single assignment; strongly connected
                 component; symbolic analysis; use-def chains",
}

@Article{Ducournau:2008:PHA,
  author =       "Roland Ducournau",
  title =        "Perfect hashing as an almost perfect subtype test",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "6",
  pages =        "33:1--33:56",
  month =        oct,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1391956.1391960",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 1 20:05:05 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Subtype tests are an important issue in the
                 implementation of object-oriented programming
                 languages. Many techniques have been proposed, but none
                 of them perfectly fulfills the five requirements that
                 we have identified: constant-time, linear-space,
                 multiple inheritance, dynamic loading and inlining. In
                 this article, we propose a subtyping test
                 implementation that involves a combination of usual
                 hashtables and Cohen's display, which is a well-known
                 technique for single inheritance hierarchies. This
                 novel approach is based on {\em perfect hashing}, that
                 is, an optimized and truly constant-time variant of
                 hashing that applies to {\em immutable\/} hashtables.
                 We show that the resulting technique closely meets all
                 five requirements. Furthermore, in the framework of
                 Java-like languages --- characterized by single
                 inheritance of classes and multiple subtyping of
                 interfaces --- perfect hashing also applies to method
                 invocation when the receiver is typed by an interface.
                 The proposed technique is compared to some
                 alternatives, including the proposal by Palacz and
                 Vitek [2003]. Time-efficiency is assessed at the cycle
                 level in the framework of Driesen's pseudo-code and the
                 linear-space criterion is validated by statistical
                 simulation on benchmarks consisting of large-scale
                 class hierarchies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "33",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Casting; coloring; downcast; dynamic loading;
                 interfaces; method tables; multiple inheritance;
                 multiple subtyping; perfect hashing; single
                 inheritance; subtype test; virtual function tables",
}

@Article{Morris:2008:DNF,
  author =       "Joseph M. Morris and Malcolm Tyrrell",
  title =        "Dually nondeterministic functions",
  journal =      j-TOPLAS,
  volume =       "30",
  number =       "6",
  pages =        "34:1--34:34",
  month =        oct,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1391956.1391961",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 1 20:05:05 MDT 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Nondeterminacy is a fundamental notion in computing.
                 We show that it can be described by a general theory
                 that accounts for it in the form in which it occurs in
                 many programming contexts, among them specifications,
                 competing agents, data refinement, abstract
                 interpretation, imperative programming, process
                 algebras, and recursion theory. Underpinning these
                 applications is a theory of nondeterministic functions;
                 we construct such a theory. The theory consists of an
                 algebra with which practitioners can reason about
                 nondeterministic functions, and a denotational model to
                 establish the soundness of the theory. The model is
                 based on the idea of free completely distributive
                 lattices over partially ordered sets. We deduce the
                 important properties of nondeterministic functions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "34",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Angelic nondeterminacy; demonic nondeterminacy; free
                 completely distributive lattice; modeling
                 nondeterminacy; nondeterminism; nondeterministic
                 functions",
}

@Article{Jacobs:2008:PMC,
  author =       "Bart Jacobs and Frank Piessens and Jan Smans and K.
                 Rustan M. Leino and Wolfram Schulte",
  title =        "A programming model for concurrent object-oriented
                 programs",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "1",
  pages =        "1:1--1:48",
  month =        dec,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1452044.1452045",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 23 11:52:52 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Reasoning about multithreaded object-oriented programs
                 is difficult, due to the nonlocal nature of object
                 aliasing and data races. We propose a programming
                 regime (or {\em programming model\/}) that rules out
                 data races, and enables local reasoning in the presence
                 of object aliasing and concurrency. Our programming
                 model builds on the multithreading and synchronization
                 primitives as they are present in current mainstream
                 programming languages. Java or C\# programs developed
                 according to our model can be annotated by means of
                 stylized comments to make the use of the model
                 explicit. We show that such annotated programs can be
                 formally verified to comply with the programming model.
                 If the annotated program verifies, the underlying Java
                 or C\# program is guaranteed to be free from data
                 races, and it is sound to reason locally about program
                 behavior. Verification is modular: a program is valid
                 if all methods are valid, and validity of a method does
                 not depend on program elements that are not visible to
                 the method. We have implemented a verifier for programs
                 developed according to our model in a custom build of
                 the Spec\# programming system, and we have validated
                 our approach on a case study.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Aliasing; data races; local reasoning; modular
                 reasoning; ownership; verification condition
                 generation",
}

@Article{Schulte:2008:ECP,
  author =       "Christian Schulte and Peter J. Stuckey",
  title =        "Efficient constraint propagation engines",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "1",
  pages =        "2:1--2:43",
  month =        dec,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1452044.1452046",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 23 11:52:52 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See erratum \cite{Schulte:2009:EEC}.",
  abstract =     "This article presents a model and implementation
                 techniques for speeding up constraint propagation.
                 Three fundamental approaches to improving constraint
                 propagation based on propagators as implementations of
                 constraints are explored: keeping track of which
                 propagators are at fixpoint, choosing which propagator
                 to apply next, and how to combine several propagators
                 for the same constraint.\par

                 We show how idempotence reasoning and events help track
                 fixpoints more accurately. We improve these methods by
                 using them dynamically (taking into account current
                 variable domains to improve accuracy). We define
                 priority-based approaches to choosing a next propagator
                 and show that dynamic priorities can improve
                 propagation. We illustrate that the use of multiple
                 propagators for the same constraint can be advantageous
                 with priorities, and introduce staged propagators that
                 combine the effects of multiple propagators with
                 priorities for greater efficiency.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Constraint (logic) programming; constraint
                 propagation; events; finite domain constraints;
                 fixpoint reasoning; priorities",
}

@Article{Bernardeschi:2008:DBV,
  author =       "C. Bernardeschi and N. {De Francesco} and G. Lettieri
                 and L. Martini and P. Masci",
  title =        "Decomposing bytecode verification by abstract
                 interpretation",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "1",
  pages =        "3:1--3:63",
  month =        dec,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1452044.1452047",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 23 11:52:52 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Bytecode verification is a key point in the security
                 chain of the Java platform. This feature is only
                 optional in many embedded devices since the memory
                 requirements of the verification process are too high.
                 In this article we propose an approach that
                 significantly reduces the use of memory by a
                 serial/parallel decomposition of the verification into
                 multiple specialized passes. The algorithm reduces the
                 type encoding space by operating on different
                 abstractions of the domain of types. The results of our
                 evaluation show that this bytecode verification can be
                 performed directly on small memory systems. The method
                 is formalized in the framework of abstract
                 interpretation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Abstract interpretation; bytecode verification",
}

@Article{Park:2008:PLB,
  author =       "Sungwoo Park and Frank Pfenning and Sebastian Thrun",
  title =        "A probabilistic language based on sampling functions",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "1",
  pages =        "4:1--4:46",
  month =        dec,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1452044.1452048",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 23 11:52:52 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "As probabilistic computations play an increasing role
                 in solving various problems, researchers have designed
                 probabilistic languages which treat probability
                 distributions as primitive datatypes. Most
                 probabilistic languages, however, focus only on
                 discrete distributions and have limited expressive
                 power. This article presents a probabilistic language,
                 called $ \lambda_o $, whose expressive power is beyond
                 discrete distributions. Rich expressiveness of $
                 \lambda_o $ is due to its use of {\em sampling
                 functions}, that is, mappings from the unit interval $
                 (0.0, 1.0] $ to probability domains, in specifying
                 probability distributions. As such, $ \lambda_o $
                 enables programmers to formally express and reason
                 about sampling methods developed in simulation theory.
                 The use of $ \lambda_o $ is demonstrated with three
                 applications in robotics: robot localization, people
                 tracking, and robotic mapping. All experiments have
                 been carried out with real robots.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Probabilistic language; probability distribution;
                 robotics; sampling function",
}

@Article{Bhargavan:2008:VII,
  author =       "Karthikeyan Bhargavan and C{\'e}dric Fournet and
                 Andrew D. Gordon and Stephen Tse",
  title =        "Verified interoperable implementations of security
                 protocols",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "1",
  pages =        "5:1--5:57",
  month =        dec,
  year =         "2008",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1452044.1452049",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 23 11:52:52 MST 2008",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present an architecture and tools for verifying
                 implementations of security protocols. Our
                 implementations can run with both concrete and symbolic
                 implementations of cryptographic algorithms. The
                 concrete implementation is for production and
                 interoperability testing. The symbolic implementation
                 is for debugging and formal verification. We develop
                 our approach for protocols written in F\#, a dialect of
                 ML, and verify them by compilation to ProVerif, a
                 resolution-based theorem prover for cryptographic
                 protocols. We establish the correctness of this
                 compilation scheme, and we illustrate our approach with
                 protocols for Web Services security.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Functional programming; pi calculus; Web services; XML
                 security",
}

@Article{DeMoura:2009:RC,
  author =       "Ana L{\'u}cia {De Moura} and Roberto Ierusalimschy",
  title =        "Revisiting coroutines",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "2",
  pages =        "6:1--6:31",
  month =        feb,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1462166.1462167",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 19 14:20:38 MST 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article advocates the revival of coroutines as a
                 convenient general control abstraction. After proposing
                 a new classification of coroutines, we introduce the
                 concept of full asymmetric coroutines and provide a
                 precise definition for it through an operational
                 semantics. We then demonstrate that full coroutines
                 have an expressive power equivalent to one-shot
                 continuations and one-shot delimited continuations. We
                 also show that full asymmetric coroutines and one-shot
                 delimited continuations have many similarities, and
                 therefore present comparable benefits. Nevertheless,
                 coroutines are easier implemented and understood,
                 especially in the realm of procedural languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Continuations; generators; multitasking",
}

@Article{Millstein:2009:EMP,
  author =       "Todd Millstein and Christopher Frost and Jason Ryder
                 and Alessandro Warth",
  title =        "Expressive and modular predicate dispatch for {Java}",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "2",
  pages =        "7:1--7:54",
  month =        feb,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1462166.1462168",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 19 14:20:38 MST 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "{\em Predicate dispatch\/} is an object-oriented (OO)
                 language mechanism for determining the method
                 implementation to be invoked upon a message send. With
                 predicate dispatch, each method implementation includes
                 a predicate guard specifying the conditions under which
                 the method should be invoked, and logical implication
                 of predicates determines the method overriding
                 relation. Predicate dispatch naturally unifies and
                 generalizes several common forms of dynamic dispatch,
                 including traditional OO dispatch, multimethod
                 dispatch, and functional-style pattern matching.
                 Unfortunately, prior languages supporting predicate
                 dispatch have had several deficiencies that limit the
                 practical utility of this language feature.\par

                 We describe JPred, a backward-compatible extension to
                 Java supporting predicate dispatch. While prior
                 languages with predicate dispatch have been extensions
                 to toy or nonmainstream languages, we show how
                 predicate dispatch can be naturally added to a
                 traditional OO language. While prior languages with
                 predicate dispatch have required the whole program to
                 be available for typechecking and compilation, JPred
                 retains Java's modular typechecking and compilation
                 strategies. While prior languages with predicate
                 dispatch have included special-purpose algorithms for
                 reasoning about predicates, JPred employs
                 general-purpose, off-the-shelf decision procedures. As
                 a result, JPred's type system is more flexible,
                 allowing several useful programming idioms that are
                 spuriously rejected by those other languages. After
                 describing the JPred language informally, we present an
                 extension to Featherweight Java that formalizes the
                 language and its modular type system, which we have
                 proven sound. Finally, we discuss two case studies that
                 illustrate the practical utility of JPred, including
                 its use in the detection of several errors.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "dynamic dispatch; modular typechecking; Predicate
                 dispatch",
}

@Article{Sneyers:2009:CPC,
  author =       "Jon Sneyers and Tom Schrijvers and Bart Demoen",
  title =        "The computational power and complexity of constraint
                 handling rules",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "2",
  pages =        "8:1--8:42",
  month =        feb,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1462166.1462169",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 19 14:20:38 MST 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Constraint Handling Rules (CHR) is a high-level
                 rule-based programming language which is increasingly
                 used for general-purpose programming. We introduce the
                 CHR machine, a model of computation based on the
                 operational semantics of CHR. Its computational power
                 and time complexity properties are compared to those of
                 the well-understood Turing machine and Random Access
                 Memory machine. This allows us to prove the interesting
                 result that every algorithm can be implemented in CHR
                 with the best known time and space complexity. We also
                 investigate the practical relevance of this result and
                 the constant factors involved. Finally we expand the
                 scope of the discussion to other (declarative)
                 programming languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "complexity; constant factors; Constraint Handling
                 Rules",
}

@Article{Schulte:2009:EEC,
  author =       "Christian Schulte and Peter J. Stuckey",
  title =        "Erratum to: {Efficient} constraint propagation
                 engines",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "2",
  pages =        "1--1",
  month =        feb,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1462166.1462170",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Feb 19 14:20:38 MST 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Schulte:2008:ECP}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{MacDonald:2009:DDP,
  author =       "Steve MacDonald and Kai Tan and Jonathan Schaeffer and
                 Duane Szafron",
  title =        "Deferring design pattern decisions and automating
                 structural pattern changes using a design-pattern-based
                 programming system",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "3",
  pages =        "9:1--9:49",
  month =        apr,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1498926.1498927",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 14:08:54 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In the design phase of software development, the
                 designer must make many fundamental design decisions
                 concerning the architecture of the system. Incorrect
                 decisions are relatively easy and inexpensive to fix if
                 caught during the design process, but the difficulty
                 and cost rise significantly if problems are not found
                 until after coding begins. Unfortunately, it is not
                 always possible to find incorrect design decisions
                 during the design phase. To reduce the cost of
                 expensive corrections, it would be useful to have the
                 ability to defer some design decisions as long as
                 possible, even into the coding stage. Failing that,
                 tool support for automating design changes would give
                 more freedom to revisit and change these decisions when
                 needed. This article shows how a design-pattern-based
                 programming system based on {\em generative design
                 patterns\/} can support the deferral of design
                 decisions where possible, and automate changes where
                 necessary. A generative design pattern is a
                 parameterized pattern form that is capable of
                 generating code for different versions of the
                 underlying design pattern. We demonstrate these ideas
                 in the context of a parallel application written with
                 the CO$_2$ P$_3$ S pattern-based parallel programming
                 system. We show that CO$_2$ P$_3$ S can defer the
                 choice of execution architecture (shared-memory or
                 distributed-memory), and can automate several changes
                 to the application structure that would normally be
                 daunting to tackle late in the development cycle.
                 Although we have done this work with a pattern-based
                 parallel programming system, it can be generalized to
                 other domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "design decisions; Design patterns; object-oriented
                 frameworks; parallel programming; software
                 maintenance",
}

@Article{Lee:2009:RFS,
  author =       "Chin Soon Lee",
  title =        "Ranking functions for size-change termination",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "3",
  pages =        "10:1--10:42",
  month =        apr,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1498926.1498928",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 14:08:54 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article explains how to construct a ranking
                 function for any program that is proved terminating by
                 {\em size-change analysis}.\par

                 The ``principle of size-change termination'' for a
                 first-order functional language with well-ordered data
                 is intuitive: A program terminates on all inputs, if
                 every infinite call sequence (following program control
                 flow) would imply an infinite descent in some data
                 values. Size-change analysis is based on information
                 associated with the subject program's call-sites. This
                 information indicates, for each call-site, strict or
                 weak data decreases observed as a computation traverses
                 the call-site. The set {\em DESC\/} of call-site
                 sequences for which the size-changes imply infinite
                 descent is $ \omega $-regular, as is the set {\em
                 FLOW\/} of infinite call-site sequences following the
                 program flowchart. If {\em FLOW\/} $ \subseteq $ {\em
                 DESC\/} (a decidable problem), every infinite call
                 sequence would imply infinite descent in a
                 well-ordering --- an impossibility --- so the program
                 must terminate.\par

                 This analysis accounts for termination arguments
                 applicable to different call-site sequences, without
                 indicating a ranking function for the program's
                 termination. In this article, it is explained how one
                 can be constructed whenever size-change analysis
                 succeeds. The constructed function has an unexpectedly
                 simple form; it is expressed using only min, max, and
                 lexicographic tuples of parameters and constants. In
                 principle, such functions can be tested to determine
                 whether size-change analysis will be successful. As a
                 corollary, if a program verified as terminating
                 performs only multiply recursive operations, the
                 function that it computes is multiply
                 recursive.\par

                 The ranking function construction is connected with the
                 determinization of the B{\"u}chi automaton for {\em
                 DESC}. While the result is not practical, it is of
                 value in addressing the scope of size-change reasoning.
                 This reasoning has been applied broadly, in the
                 analysis of functional and logic programs, as well as
                 term rewrite systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "-Automaton; determinization; multiple recursion; omega
                 ranking function; size-change termination; termination
                 analysis",
}

@Article{OHearn:2009:SIH,
  author =       "Peter W. O'Hearn and Hongseok Yang and John C.
                 Reynolds",
  title =        "Separation and information hiding",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "3",
  pages =        "11:1--11:50",
  month =        apr,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1498926.1498929",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 14:08:54 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We investigate proof rules for information hiding,
                 using the formalism of separation logic. In essence, we
                 use the separating conjunction to partition the
                 internal resources of a module from those accessed by
                 the module's clients. The use of a logical connective
                 gives rise to a form of dynamic partitioning, where we
                 track the transfer of ownership of portions of heap
                 storage between program components. It also enables us
                 to enforce separation in the presence of mutable data
                 structures with embedded addresses that may be
                 aliased.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "modularity; resource protection; Separation logic",
}

@Article{Matthews:2009:OSM,
  author =       "Jacob Matthews and Robert Bruce Findler",
  title =        "Operational semantics for multi-language programs",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "3",
  pages =        "12:1--12:44",
  month =        apr,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1498926.1498930",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 14:08:54 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Interoperability is big business, a fact to which
                 .NET, the JVM, and COM can attest. Language designers
                 are well aware of this, and they are designing
                 programming languages that reflect it --- for instance,
                 SML.NET, F\#, Mondrian, and Scala all treat
                 interoperability as a central design feature. Still,
                 current multi-language research tends not to focus on
                 the semantics of these features, but only on how to
                 implement them efficiently. In this article, we attempt
                 to rectify that by giving a technique for specifying
                 the operational semantics of a multi-language system as
                 a composition of the models of its constituent
                 languages. Our technique abstracts away the low-level
                 details of interoperability like garbage collection and
                 representation coherence, and lets us focus on semantic
                 properties like type-safety, equivalence, and
                 termination behavior. In doing so it allows us to adapt
                 standard theoretical techniques such as
                 subject-reduction, logical relations, and operational
                 equivalence for use on multi-language systems.
                 Generally speaking, our proofs of properties in a
                 multi-language context are mutually referential
                 versions of their single language counterparts.\par

                 We demonstrate our technique with a series of
                 strategies for embedding a Scheme-like language into an
                 ML-like language. We start by connecting very simple
                 languages with a very simple strategy, and work our way
                 up to languages that interact in sophisticated ways and
                 have sophisticated features such as polymorphism and
                 effects. Along the way, we prove relevant results such
                 as type-soundness and termination for each system we
                 present using adaptations of standard
                 techniques.\par

                 Beyond giving simple expressive models, our studies
                 have uncovered several interesting facts about
                 interoperability. For example, higher-order function
                 contracts naturally emerge as the glue to ensure that
                 interoperating languages respect each other's type
                 systems. Our models also predict that the embedding
                 strategy where foreign values are opaque is as
                 expressive as the embedding strategy where foreign
                 values are translated to corresponding values in the
                 other language, and we were able to experimentally
                 verify this behavior using PLT Scheme's foreign
                 function interface.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "interoperability; Operational semantics",
}

@Article{Ariola:2009:SCA,
  author =       "Zena M. Ariola and Aaron Bohannon and Amr Sabry",
  title =        "Sequent calculi and abstract machines",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "4",
  pages =        "13:1--13:48",
  month =        may,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1516507.1516508",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 23 09:05:20 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose a sequent calculus derived from the $
                 \lambda - \mu \mu \char `{\~ $}-calculus of Curien and
                 Herbelin that is expressive enough to directly
                 represent the fine details of program evaluation using
                 typical abstract machines. Not only does the calculus
                 easily encode the usual components of abstract machines
                 such as environments and stacks, but it can also
                 simulate the transition steps of the abstract machine
                 with just a constant overhead. Technically this is
                 achieved by ensuring that reduction in the calculus
                 always happens at a bounded depth from the root of the
                 term. We illustrate these properties by providing {\em
                 shallow encodings\/} of the Krivine (call-by-name) and
                 the CEK (call-by-value) abstract machines in the
                 calculus.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Curry--Howard isomorphism; duality; explicit
                 substitutions; Krivine machine; natural deduction",
}

@Article{Kalvala:2009:PTU,
  author =       "Sara Kalvala and Richard Warburton and David Lacey",
  title =        "Program transformations using temporal logic side
                 conditions",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "4",
  pages =        "14:1--14:48",
  month =        may,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1516507.1516509",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 23 09:05:20 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article describes an approach to program
                 optimization based on transformations, where temporal
                 logic is used to specify side conditions, and
                 strategies are created which expand the repertoire of
                 transformations and provide a suitable level of
                 abstraction. We demonstrate the power of this approach
                 by developing a set of optimizations using our
                 transformation language and showing how the
                 transformations can be converted into a form which
                 makes it easier to apply them, while maintaining trust
                 in the resulting optimizing steps. The approach is
                 illustrated through a transformational case study where
                 we apply several optimizations to a small program.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "optimizing compilers; program transformation;
                 rewriting; temporal logic",
}

@Article{Sangiorgi:2009:OBC,
  author =       "Davide Sangiorgi",
  title =        "On the origins of bisimulation and coinduction",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "4",
  pages =        "15:1--15:41",
  month =        may,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1516507.1516510",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 23 09:05:20 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The origins of bisimulation and bisimilarity are
                 examined, in the three fields where they have been
                 independently discovered: Computer Science,
                 Philosophical Logic (precisely, Modal Logic), Set
                 Theory.\par

                 Bisimulation and bisimilarity are coinductive notions,
                 and as such are intimately related to fixed points, in
                 particular greatest fixed points. Therefore also the
                 appearance of coinduction and fixed points is
                 discussed, though in this case only within Computer
                 Science. The paper ends with some historical remarks on
                 the main fixed-point theorems (such as Knaster-Tarski)
                 that underpin the fixed-point theory presented.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "bisimulation; coinduction; fixed points; greatest
                 fixed points; history",
}

@Article{Morris:2009:TTN,
  author =       "Joseph M. Morris and Alexander Bunkenburg and Malcolm
                 Tyrrell",
  title =        "Term transformers: a new approach to state",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "4",
  pages =        "16:1--16:42",
  month =        may,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1516507.1516511",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 23 09:05:20 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a new approach to adding state and
                 state-changing commands to a term language. As a formal
                 semantics it can be seen as a generalization of
                 predicate transformer semantics, but beyond that it
                 brings additional opportunities for specifying and
                 verifying programs. It is based on a construct called a
                 {\em phrase}, which is a term of the form $ C
                 \triangleright t $, where $C$ stands for a command and
                 $t$ stands for a term of any type. If $R$ is boolean, $
                 C \triangleright R$ is closely related to the weakest
                 precondition $ \mbox {wp}(C, R)$. The new theory draws
                 together functional and imperative programming in a
                 simple way. In particular, imperative procedures and
                 functions are seen to be governed by the same laws as
                 classical functions. We get new techniques for
                 reasoning about programs, including the ability to
                 dispense with logical variables and their attendant
                 complexities. The theory covers both programming and
                 specification languages, and supports unbounded demonic
                 and angelic nondeterminacy in both commands and
                 terms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "nondeterminacy; nondeterminism; predicate
                 transformers; procedures; refinement calculus; state",
}

@Article{Pingali:2009:RTP,
  author =       "Keshav Pingali and Kathryn McKinley",
  title =        "Remembrances of things past",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "4",
  pages =        "17:1--17:2",
  month =        may,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1538824.1538825",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat May 23 09:05:20 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Yardimci:2009:MSP,
  author =       "Efe Yardimci and Michael Franz",
  title =        "Mostly static program partitioning of binary
                 executables",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "5",
  pages =        "17:1--17:46",
  month =        jun,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1538917.1538918",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 2 12:30:17 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We have built a runtime compilation system that takes
                 unmodified sequential binaries and improves their
                 performance on off-the-shelf multiprocessors using
                 dynamic vectorization and loop-level parallelization
                 techniques. Our system, Azure, is purely software based
                 and requires no specific hardware support for
                 speculative thread execution, yet it is able to break
                 even in most cases; that is, the achieved speedup
                 exceeds the cost of runtime monitoring and compilation,
                 often by significant amounts.\par

                 Key to this remarkable performance is an offline
                 preprocessing step that extracts a {\em mostly
                 correct\/} control flow graph (CFG) from the binary
                 program ahead of time. This statically obtained CFG is
                 incomplete in that it may be missing some edges
                 corresponding to computed branches. We describe how
                 such additional control flow edges are discovered and
                 handled at runtime, so that an incomplete static
                 analysis never leads to an incorrect optimization
                 result.\par

                 The availability of a {\em mostly correct\/} CFG
                 enables us to statically partition a binary executable
                 into single-entry multiple-exit regions and to identify
                 potential parallelization candidates ahead of
                 execution. Program regions that are not candidates for
                 parallelization can thereby be excluded completely from
                 runtime monitoring and dynamic recompilation. Azure's
                 extremely low overhead is a direct consequence of this
                 design.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "binary translation; Continuous compilation and
                 optimization; dynamic parallelization",
}

@Article{Barthe:2009:CTO,
  author =       "Gilles Barthe and Benjamin Gr{\'e}goire and C{\'e}sar
                 Kunz and Tamara Rezk",
  title =        "Certificate translation for optimizing compilers",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "5",
  pages =        "18:1--18:45",
  month =        jun,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1538917.1538919",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 2 12:30:17 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Proof Carrying Code provides trust in mobile code by
                 requiring certificates that ensure the code adherence
                 to specific conditions. The prominent approach to
                 generate certificates for compiled code is Certifying
                 Compilation, that automatically generates certificates
                 for simple safety properties.\par

                 In this work, we present Certificate Translation, a
                 novel extension for standard compilers that
                 automatically transforms formal proofs for more
                 expressive and complex properties of the source program
                 to certificates for the compiled code.\par

                 The article outlines the principles of certificate
                 translation, instantiated for a nonoptimizing compiler
                 and for standard compiler optimizations in the context
                 of an intermediate RTL Language.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "program optimizations; program verification;
                 Proof-carrying code; static analysis",
}

@Article{Castagna:2009:TCW,
  author =       "Giuseppe Castagna and Nils Gesbert and Luca Padovani",
  title =        "A theory of contracts for {Web} services",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "5",
  pages =        "19:1--19:61",
  month =        jun,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1538917.1538920",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 2 12:30:17 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Contracts are behavioral descriptions of Web services.
                 We devise a theory of contracts that formalizes the
                 compatibility of a client with a service, and the safe
                 replacement of a service with another service. The use
                 of contracts statically ensures the successful
                 completion of every possible interaction between
                 compatible clients and services.\par

                 The technical device that underlies the theory is the
                 {\em filter}, which is an explicit coercion preventing
                 some possible behaviors of services and, in doing so,
                 make services compatible with different usage
                 scenarios. We show that filters can be seen as proofs
                 of a sound and complete subcontracting deduction system
                 which simultaneously refines and extends Hennessy's
                 classical axiomatization of the must testing preorder.
                 The relation is decidable, and the decision algorithm
                 is obtained via a cut-elimination process that proves
                 the coherence of subcontracting as a logical
                 system.\par

                 Despite the richness of the technical development, the
                 resulting approach is based on simple ideas and basic
                 intuitions. Remarkably, its application is mostly
                 independent of the language used to program the
                 services or the clients. We outline the practical
                 aspects of our theory by studying two different
                 concrete syntaxes for contracts and applying each of
                 them to Web services languages. We also explore
                 implementation issues of filters and discuss the
                 perspectives of future research this work opens.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "ccs; concurrency theory; contracts; explicit
                 coercions; must testing; subtyping; type theory; Web
                 services",
}

@Article{Zhong:2009:PLA,
  author =       "Yutao Zhong and Xipeng Shen and Chen Ding",
  title =        "Program locality analysis using reuse distance",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "6",
  pages =        "20:1--20:39",
  month =        aug,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1552309.1552310",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Aug 24 13:23:06 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "On modern computer systems, the memory performance of
                 an application depends on its locality. For a single
                 execution, locality-correlated measures like average
                 miss rate or working-set size have long been analyzed
                 using {\em reuse distance\/} --- the number of distinct
                 locations accessed between consecutive accesses to a
                 given location. This article addresses the analysis
                 problem at the program level, where the size of data
                 and the locality of execution may change significantly
                 depending on the input.\par

                 The article presents two techniques that predict how
                 the locality of a program changes with its input. The
                 first is approximate reuse-distance measurement, which
                 is asymptotically faster than exact methods while
                 providing a guaranteed precision. The second is
                 statistical prediction of locality in all executions of
                 a program based on the analysis of a few executions.
                 The prediction process has three steps: dividing data
                 accesses into groups, finding the access patterns in
                 each group, and building parameterized models. The
                 resulting prediction may be used on-line with the help
                 of distance-based sampling. When evaluated on fifteen
                 benchmark applications, the new techniques predicted
                 program locality with good accuracy, even for test
                 executions that are orders of magnitude larger than the
                 training executions.\par

                 The two techniques are among the first to enable
                 quantitative analysis of whole-program locality in
                 general sequential code. These findings form the basis
                 for a unified understanding of program locality and its
                 many facets. Concluding sections of the article present
                 a taxonomy of related literature along five dimensions
                 of locality and discuss the role of reuse distance in
                 performance modeling, program optimization, cache and
                 virtual memory management, and network traffic
                 analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Program locality; reuse distance; stack distance;
                 training-based analysis",
}

@Article{Liu:2009:DRE,
  author =       "Yanhong A. Liu and Scott D. Stoller",
  title =        "From datalog rules to efficient programs with time and
                 space guarantees",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "6",
  pages =        "21:1--21:38",
  month =        aug,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1552309.1552311",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Aug 24 13:23:06 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article describes a method for transforming any
                 given set of Datalog rules into an efficient
                 specialized implementation with guaranteed worst-case
                 time and space complexities, and for computing the
                 complexities from the rules. The running time is
                 optimal in the sense that only useful combinations of
                 facts that lead to all hypotheses of a rule being
                 simultaneously true are considered, and each such
                 combination is considered exactly once in constant
                 time. The associated space usage may sometimes be
                 reduced using scheduling optimizations to eliminate
                 some summands in the space usage formula. The
                 transformation is based on a general method for
                 algorithm design that exploits fixed-point computation,
                 incremental maintenance of invariants, and combinations
                 of indexed and linked data structures. We apply the
                 method to a number of analysis problems, some with
                 improved algorithm complexities and all with greatly
                 improved algorithm understanding and greatly simplified
                 complexity analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Complexity analysis; data structure design; Datalog;
                 incremental computation; indexed representations;
                 indexing; linked representations; optimization; program
                 transformation; recursion; tabling",
}

@Article{Dolev:2009:SSP,
  author =       "Shlomi Dolev and Yinnon Haviv and Mooly Sagiv",
  title =        "Self-stabilization preserving compiler",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "6",
  pages =        "22:1--22:22",
  month =        aug,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1552309.1552312",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Aug 24 13:23:06 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Self-stabilization is an elegant approach for
                 designing fault tolerant systems. A system is
                 considered self-stabilizing if, starting in any state,
                 it converges to the desired behavior. Self-stabilizing
                 algorithms were designed for solving fundamental
                 distributed tasks, such as leader election, token
                 circulation and communication network protocols. The
                 algorithms were expressed using guarded commands or
                 pseudo-code. The realization of these algorithms
                 requires the existence of a (self-stabilizing)
                 infrastructure such as a self-stabilizing
                 microprocessor and a self-stabilizing operating system
                 for their execution. Moreover, the high-level
                 description of the algorithms needs to be converted
                 into machine language of the microprocessor. In this
                 article, we present our design for a self-stabilization
                 preserving compiler. The compiler we designed and
                 implemented transforms programs written in a language
                 similar to the abstract state machine (ASM). The
                 compiler preserves the stabilization property of the
                 high level program.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "abstract state machines; Compilers;
                 self-stabilization",
}

@Article{Bartoletti:2009:LPR,
  author =       "Massimo Bartoletti and Pierpaolo Degano and Gian-Luigi
                 Ferrari and Roberto Zunino",
  title =        "Local policies for resource usage analysis",
  journal =      j-TOPLAS,
  volume =       "31",
  number =       "6",
  pages =        "23:1--23:43",
  month =        aug,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1552309.1552313",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Aug 24 13:23:06 MDT 2009",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "An extension of the $ \lambda $-calculus is proposed,
                 to study resource usage analysis and verification. It
                 features usage policies with a possibly nested, local
                 scope, and dynamic creation of resources. We define a
                 type and effect system that, given a program, extracts
                 a history expression, that is, a sound
                 overapproximation to the set of histories obtainable at
                 runtime. After a suitable transformation, history
                 expressions are model-checked for validity. A program
                 is resource-safe if its history expression is verified
                 valid: If such, no runtime monitor is needed to safely
                 drive its executions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "model-checking; type and effect systems; Usage
                 policies",
}

@Article{Harman:2009:DCS,
  author =       "Mark Harman and David Binkley and Keith Gallagher and
                 Nicolas Gold and Jens Krinke",
  title =        "Dependence clusters in source code",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "1",
  pages =        "1:1--1:33",
  month =        oct,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1596527.1596528",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:16 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A dependence cluster is a set of program statements,
                 all of which are mutually inter-dependent. This article
                 reports a large scale empirical study of dependence
                 clusters in C program source code. The study reveals
                 that large dependence clusters are surprisingly
                 commonplace. Most of the 45 programs studied have
                 clusters of dependence that consume more than 10\% of
                 the whole program. Some even have clusters consuming
                 80\% or more. The widespread existence of clusters has
                 implications for source code analyses such as program
                 comprehension, software maintenance, software testing,
                 reverse engineering, reuse, and parallelization.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Dependence; program comprehension; program slicing",
}

@Article{Hosoya:2009:PPX,
  author =       "Haruo Hosoya and Alain Frisch and Giuseppe Castagna",
  title =        "Parametric polymorphism for {XML}",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "1",
  pages =        "2:1--2:56",
  month =        oct,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1596527.1596529",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:16 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Despite the extensiveness of recent investigations on
                 static typing for XML, parametric polymorphism has
                 rarely been treated. This well-established typing
                 discipline can also be useful in XML processing in
                 particular for programs involving ``parametric
                 schemas,'' that is, schemas parameterized over other
                 schemas (e.g., SOAP). The difficulty in treating
                 polymorphism for XML lies in how to extend the
                 ``semantic'' approach used in the mainstream
                 (monomorphic) XML type systems. A naive extension would
                 be ``semantic'' quantification over all substitutions
                 for type variables. However, this approach reduces to
                 an NEXPTIME-complete problem for which no practical
                 algorithm is known and induces a subtyping relation
                 that may not always match the programmer's intuition.
                 In this article, we propose a different method that
                 smoothly extends the semantic approach yet is
                 algorithmically easier. The key idea here is to devise
                 a novel and simple {\em marking\/} technique, where we
                 interpret a polymorphic type as a set of values with
                 annotations of which subparts are parameterized. We
                 exploit this interpretation in every ingredient of our
                 polymorphic type system such as subtyping, inference of
                 type arguments, etc. As a result, we achieve a sensible
                 system that directly represents a usual expected
                 behavior of polymorphic type systems --- ``values of
                 abstract types are never reconstructed'' --- in a
                 reminiscence of Reynold's parametricity theory. Also,
                 we obtain a set of practical algorithms for
                 typechecking by local modifications to existing ones
                 for a monomorphic system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "polymorphism; subtyping; tree automata; XML",
}

@Article{Acar:2009:EAS,
  author =       "Umut A. Acar and Guy E. Blelloch and Matthias Blume
                 and Robert Harper and Kanat Tangwongsan",
  title =        "An experimental analysis of self-adjusting
                 computation",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "1",
  pages =        "3:1--3:53",
  month =        oct,
  year =         "2009",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1596527.1596530",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:16 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Recent work on adaptive functional programming (AFP)
                 developed techniques for writing programs that can
                 respond to modifications to their data by performing
                 {\em change propagation}. To achieve this, executions
                 of programs are represented with {\em dynamic
                 dependence graphs\/} (DDGs) that record data
                 dependences and control dependences in a way that a
                 change-propagation algorithm can update the computation
                 as if the program were from scratch, by re-executing
                 only the parts of the computation affected by the
                 changes. Since change-propagation only re-executes
                 parts of the computation, it can respond to certain
                 incremental modifications asymptotically faster than
                 recomputing from scratch, potentially offering
                 significant speedups. Such asymptotic speedups,
                 however, are rare: for many computations and
                 modifications, change propagation is no faster than
                 recomputing from scratch.\par

                 In this article, we realize a duality between dynamic
                 dependence graphs and memoization, and combine them to
                 give a change-propagation algorithm that can
                 dramatically increase computation reuse. The key idea
                 is to use DDGs to identify and re-execute the parts of
                 the computation that are affected by modifications,
                 while using memoization to identify the parts of the
                 computation that remain unaffected by the changes. We
                 refer to this approach as self-adjusting computation.
                 Since DDGs are imperative, but (traditional)
                 memoization requires purely functional computation,
                 reusing computation correctly via memoization becomes a
                 challenge. We overcome this challenge with a technique
                 for remembering and reusing not just the results of
                 function calls (as in conventional memoization), but
                 their executions represented with DDGs. We show that
                 the proposed approach is realistic by describing a
                 library for self-adjusting computation, presenting
                 efficient algorithms for realizing the library, and
                 describing and evaluating an implementation. Our
                 experimental evaluation with a variety of applications,
                 ranging from simple list primitives to more
                 sophisticated computational geometry algorithms, shows
                 that the approach is effective in practice: compared to
                 recomputing from-scratch; self-adjusting programs
                 respond to small modifications to their data orders of
                 magnitude faster.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Computational geometry; dynamic algorithms; dynamic
                 dependence graphs; memoization; performance;
                 self-adjusting computation",
}

@Article{Markstrum:2010:JDP,
  author =       "Shane Markstrum and Daniel Marino and Matthew Esquivel
                 and Todd Millstein and Chris Andreae and James Noble",
  title =        "{JavaCOP}: {Declarative} pluggable types for {Java}",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "2",
  pages =        "4:1--4:37",
  month =        jan,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1667048.1667049",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:35 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Pluggable types enable users to enforce multiple type
                 systems in one programming language. We have developed
                 a suite of tools, called the JavaCOP framework, that
                 allows developers to create pluggable type systems for
                 Java. JavaCOP provides a simple declarative language in
                 which program constraints are defined over a program's
                 abstract syntax tree. The JavaCOP compiler
                 automatically enforces these constraints on programs
                 during compilation. The JavaCOP framework also includes
                 a dataflow analysis API in order to support type
                 systems which depend on flow-sensitive information.
                 Finally, JavaCOP includes a novel test framework which
                 helps users gain confidence in the correctness of their
                 pluggable type systems. We demonstrate the framework by
                 discussing a number of pluggable type systems which
                 have been implemented in JavaCOP in order to detect
                 errors and enforce strong invariants in programs. These
                 type systems range from general-purpose checkers, such
                 as a type system for nonnull references, to
                 domain-specific ones, such as a checker for conformance
                 to a library's usage rules.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "JavaCOP; pluggable type systems",
}

@Article{Jeannet:2010:RAI,
  author =       "Bertrand Jeannet and Alexey Loginov and Thomas Reps
                 and Mooly Sagiv",
  title =        "A relational approach to interprocedural shape
                 analysis",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "2",
  pages =        "5:1--5:52",
  month =        jan,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1667048.1667050",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:35 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article addresses the verification of properties
                 of imperative programs with recursive procedure calls,
                 heap-allocated storage, and destructive updating of
                 pointer-valued fields, that is, {\em interprocedural
                 shape analysis}. The article makes three
                 contributions.\par

                 --- It introduces a new method for abstracting
                 relations over memory configurations for use in
                 abstract interpretation.\par

                 --- It shows how this method furnishes the elements
                 needed for a compositional approach to shape analysis.
                 In particular, abstracted relations are used to
                 represent the shape transformation performed by a
                 sequence of operations, and an overapproximation to
                 relational composition can be performed using the meet
                 operation of the domain of abstracted
                 relations.\par

                 --- It applies these ideas in a new algorithm for
                 context-sensitive interprocedural shape analysis. The
                 algorithm creates procedure summaries using abstracted
                 relations over memory configurations, and the
                 meet-based composition operation provides a way to
                 apply the summary transformer for a procedure $P$ at
                 each call site from which $P$ is called.\par

                 The algorithm has been applied successfully to
                 establish properties of both (i) recursive programs
                 that manipulate lists and (ii) recursive programs that
                 manipulate binary trees.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "3-valued logic; Abstract interpretation;
                 context-sensitive analysis; destructive updating;
                 interprocedural dataflow analysis; pointer analysis;
                 shape analysis; static analysis",
}

@Article{Knowles:2010:HTC,
  author =       "Kenneth Knowles and Cormac Flanagan",
  title =        "Hybrid type checking",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "2",
  pages =        "6:1--6:34",
  month =        jan,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1667048.1667051",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:35 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Traditional static type systems are effective for
                 verifying basic interface specifications. Dynamically
                 checked contracts support more precise specifications,
                 but these are not checked until runtime, resulting in
                 incomplete detection of defects. Hybrid type checking
                 is a synthesis of these two approaches that enforces
                 precise interface specifications, via static analysis
                 where possible, but also via dynamic checks where
                 necessary. This article explores the key ideas and
                 implications of hybrid type checking, in the context of
                 the $ \lambda $-calculus extended with {\em contract
                 types}, that is, with dependent function types and with
                 arbitrary refinements of base types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "contracts; dynamic checking; static checking; Type
                 systems",
}

@Article{Ahmed:2010:SFT,
  author =       "Amal Ahmed and Andrew W. Appel and Christopher D.
                 Richards and Kedar N. Swadi and Gang Tan and Daniel C.
                 Wang",
  title =        "Semantic foundations for typed assembly languages",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "3",
  pages =        "7:1--7:67",
  month =        mar,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1709093.1709094",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:48 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Typed Assembly Languages (TALs) are used to validate
                 the safety of machine-language programs. The
                 Foundational Proof-Carrying Code project seeks to
                 verify the soundness of TALs using the smallest
                 possible set of axioms: the axioms of a suitably
                 expressive logic plus a specification of machine
                 semantics. This article proposes general semantic
                 foundations that permit modular proofs of the soundness
                 of TALs. These semantic foundations include Typed
                 Machine Language (TML), a type theory for specifying
                 properties of low-level data with powerful and
                 orthogonal type constructors, and $ L_c $, a
                 compositional logic for specifying properties of
                 machine instructions with simplified reasoning about
                 unstructured control flow. Both of these components,
                 whose semantics we specify using higher-order logic,
                 are useful for proving the soundness of TALs. We
                 demonstrate this by using TML and $ L_c $ to verify the
                 soundness of a low-level, typed assembly language,
                 LTAL, which is the target of our core-ML-to-sparc
                 compiler.\par

                 To prove the soundness of the TML type system we have
                 successfully applied a new approach, that of {\em
                 step-indexed logical relations}. This approach provides
                 the first semantic model for a type system with
                 updatable references to values of impredicative
                 quantified types. Both impredicative polymorphism and
                 mutable references are essential when representing
                 function closures in compilers with typed closure
                 conversion, or when compiling objects to simpler typed
                 primitives.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "control flow; logical relations; proof-carrying code;
                 semantic models; Typed assembly languages",
}

@Article{Spoto:2010:TAJ,
  author =       "Fausto Spoto and Fred Mesnard and {\'E}tienne Payet",
  title =        "A termination analyzer for {Java} bytecode based on
                 path-length",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "3",
  pages =        "8:1--8:70",
  month =        mar,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1709093.1709095",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:48 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "It is important to prove that supposedly terminating
                 programs actually terminate, particularly if those
                 programs must be run on critical systems or downloaded
                 into a client such as a mobile phone. Although
                 termination of computer programs is generally
                 undecidable, it is possible and useful to prove
                 termination of a large, nontrivial subset of the
                 terminating programs. In this article, we present our
                 termination analyzer for sequential Java bytecode,
                 based on a program property called {\em path-length}.
                 We describe the analyses which are needed before the
                 path-length can be computed such as sharing, cyclicity,
                 and aliasing. Then we formally define the path-length
                 analysis and prove it correct with respect to a
                 reference denotational semantics of the bytecode. We
                 show that a constraint logic program $ P_{{\em CLP \/
                 }} $ can be built from the result of the path-length
                 analysis of a Java bytecode program {\em P\/} and
                 formally prove that if $ P_{{\em CLP \/ }} $
                 terminates, then $P$ also terminates. Hence a
                 termination prover for constraint logic programs can be
                 applied to prove the termination of $P$. We conclude
                 with some discussion of the possibilities and
                 limitations of our approach. Ours is the first existing
                 termination analyzer for Java bytecode dealing with any
                 kind of data structures dynamically allocated on the
                 heap and which does not require any help or annotation
                 on the part of the user.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Abstract interpretation; Java; Java bytecode;
                 termination analysis",
}

@Article{VanNieuwpoort:2010:SHL,
  author =       "Rob V. {Van Nieuwpoort} and Gosia Wrzesi{\'n}ska and
                 Ceriel J. H. Jacobs and Henri E. Bal",
  title =        "{Satin}: a high-level and efficient grid programming
                 model",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "3",
  pages =        "9:1--9:39",
  month =        mar,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1709093.1709096",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:46:48 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Computational grids have an enormous potential to
                 provide compute power. However, this power remains
                 largely unexploited today for most applications, except
                 trivially parallel programs. Developing parallel grid
                 applications simply is too difficult. Grids introduce
                 several problems not encountered before, mainly due to
                 the highly heterogeneous and dynamic computing and
                 networking environment. Furthermore, failures occur
                 frequently, and resources may be claimed by
                 higher-priority jobs at any time.\par

                 In this article, we solve these problems for an
                 important class of applications: divide-and-conquer. We
                 introduce a system called Satin that simplifies the
                 development of parallel grid applications by providing
                 a rich high-level programming model that completely
                 hides communication. All grid issues are transparently
                 handled in the runtime system, not by the programmer.
                 Satin's programming model is based on Java, features
                 spawn-sync primitives and shared objects, and uses
                 asynchronous exceptions and an abort mechanism to
                 support speculative parallelism.\par

                 To allow an efficient implementation, Satin
                 consistently exploits the idea that grids are
                 hierarchically structured. Dynamic load-balancing is
                 done with a novel cluster-aware scheduling algorithm
                 that hides the long wide-area latencies by overlapping
                 them with useful local work. Satin's shared object
                 model lets the application define the consistency model
                 it needs. If an application needs only loose
                 consistency, it does not have to pay high performance
                 penalties for wide-area communication and
                 synchronization.\par

                 We demonstrate how grid problems such as resource
                 changes and failures can be handled transparently and
                 efficiently. Finally, we show that adaptivity is
                 important in grids. Satin can increase performance
                 considerably by adding and removing compute resources
                 automatically, based on the application's requirements
                 and the utilization of the machines and networks in the
                 grid.\par

                 Using an extensive evaluation on real grids with up to
                 960 cores, we demonstrate that it is possible to
                 provide a simple high-level programming model for
                 divide-and-conquer applications, while achieving
                 excellent performance on grids. At the same time, we
                 show that the divide-and-conquer model scales better on
                 large systems than the master-worker approach, since it
                 has no single central bottleneck.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "divide-and-conquer; Grid computing; programming
                 model",
}

@Article{Mckinley:2010:DVT,
  author =       "Kathryn S. Mckinley and Keshav Pingali",
  title =        "La dolce vita at {TOPLAS}",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "10:1--10:6",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734207",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Zhuang:2010:OFE,
  author =       "Xiaotong Zhuang and Santosh Pande",
  title =        "An optimization framework for embedded processors with
                 auto-addressing mode",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "11:1--11:41",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734208",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Modern embedded processors with dedicated address
                 generation unit support memory accesses through
                 auto-increment/decrement addressing mode. The
                 auto-increment/decrement mode, if properly utilized,
                 can save address arithmetic instructions, reduce static
                 and dynamic memory footprint of the program, and speed
                 up the execution as well.\par

                 Liao [1995, 1996] categorized this problem as Simple
                 Offset Assignment (SOA) and General Offset Assignment
                 (GOA), which involves storage layout of variables and
                 assignment of address registers, respectively,
                 proposing several heuristic solutions. This article
                 proposes a new direction for investigating the solution
                 space of the problem. The general idea [Zhuang 2003] is
                 to perform simplification of the underlying access
                 graph through coalescence of the memory locations of
                 program variables. A comprehensive framework is
                 proposed including coalescence-based offset assignment
                 and post/pre-optimization. Variables not interfering
                 with others (not simultaneously live at any program
                 point) can be coalesced into the same memory location.
                 Coalescing allows simplifications of the access graph
                 yielding better SOA solutions; it also reduces the
                 address register pressure to such low values that some
                 GOA solutions become optimal. Moreover, it can reduce
                 the memory footprint both statically and at runtime for
                 stack variables. Our second optimization
                 (post/pre-optimization) considers both post- and
                 pre-modification mode for optimizing code across basic
                 blocks, which makes it useful. Making use of both
                 addressing modes further reduces SOA/GOA cost and our
                 post/pre-optimization phase is optimal in selecting
                 post or pre mode after variable offsets have been
                 determined.\par

                 We have shown the advantages of our framework over
                 previous approaches to capture more opportunities to
                 reduce both stack size and SOA/GOA cost, leading to
                 more speedup.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "auto-modification addressing mode; digital signal
                 processing; GOA; layout assignment; Offset assignment;
                 SOA; variable coalescence",
}

@Article{Sewell:2010:NPP,
  author =       "Peter Sewell and Pawe{\l} T. Wojciechowski and Asis
                 Unyapoth",
  title =        "Nomadic pict: {Programming} languages, communication
                 infrastructure overlays, and semantics for mobile
                 computation",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "12:1--12:63",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734209",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Mobile computation, in which executing computations
                 can move from one physical computing device to another,
                 is a recurring theme: from OS process migration, to
                 language-level mobility, to virtual machine migration.
                 This article reports on the design, implementation, and
                 verification of overlay networks to support reliable
                 communication between migrating computations, in the
                 Nomadic Pict project. We define two levels of
                 abstraction as calculi with precise semantics: a
                 low-level Nomadic $ \pi $ calculus with migration and
                 location-dependent communication, and a high-level
                 calculus that adds location-independent communication.
                 Implementations of location-independent communication,
                 as overlay networks that track migrations and forward
                 messages, can be expressed as translations of the
                 high-level calculus into the low. We discuss the design
                 space of such overlay network algorithms and define
                 three precisely, as such translations. Based on the
                 calculi, we design and implement the Nomadic Pict
                 distributed programming language, to let such
                 algorithms (and simple applications above them) to be
                 quickly prototyped. We go on to develop the semantic
                 theory of the Nomadic $ \pi $ calculi, proving
                 correctness of one example overlay network. This
                 requires novel equivalences and congruence results that
                 take migration into account, and reasoning principles
                 for agents that are temporarily immobile (e.g., waiting
                 on a lock elsewhere in the system). The whole stands as
                 a demonstration of the use of principled semantics to
                 address challenging system design problems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Suhendra:2010:SAC,
  author =       "Vivy Suhendra and Abhik Roychoudhury and Tulika
                 Mitra",
  title =        "Scratchpad allocation for concurrent embedded
                 software",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "13:1--13:47",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734210",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Software-controlled scratchpad memory is increasingly
                 employed in embedded systems as it offers better timing
                 predictability compared to caches. Previous scratchpad
                 allocation algorithms typically consider single-process
                 applications. But embedded applications are mostly
                 multitasking with real-time constraints, where the
                 scratchpad memory space has to be shared among
                 interacting processes that may preempt each other. In
                 this work, we develop a novel dynamic scratchpad
                 allocation technique that takes these process
                 interferences into account to improve the performance
                 and predictability of the memory system. We model the
                 application as a Message Sequence Chart (MSC) to best
                 capture the interprocess interactions. Our goal is to
                 optimize the Worst-Case Response Time (WCRT) of the
                 application through runtime reloading of the scratchpad
                 memory content at appropriate execution points. We
                 propose an iterative allocation algorithm that consists
                 of two critical steps: (1) analyze the MSC along with
                 the existing allocation to determine potential
                 interference patterns, and (2) exploit this
                 interference information to tune the scratchpad
                 reloading points and content so as to best improve the
                 WCRT. We present various alternative scratchpad
                 allocation heuristics and evaluate their effectiveness
                 in reducing the WCRT. The scheme is also extended to
                 work on Message Sequence Graph models. We evaluate our
                 memory allocation scheme on two real-world embedded
                 applications controlling an Unmanned Aerial Vehicle
                 (UAV) and an in-orbit monitoring instrument,
                 respectively.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "compiler controlled memories; message sequence chart;
                 multicore architectures; Scratchpad memory; UML
                 sequence diagram; worst-case response time",
}

@Article{Welch:2010:SCF,
  author =       "Peter H. Welch and Jan B. Pedersen",
  title =        "{Santa Claus}: {Formal} analysis of a process-oriented
                 solution",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "14:1--14:37",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734211",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "With the commercial development of multicore
                 processors, the challenges of writing multithreaded
                 programs to take advantage of these new hardware
                 architectures are becoming more and more pertinent.
                 Concurrent programming is necessary to achieve the
                 performance that the hardware offers. Traditional
                 approaches present concurrency as an {\em advanced\/}
                 topic: they have proven difficult to use, reason about
                 with confidence, and scale up to high levels of
                 concurrency. This article reviews {\em process-oriented
                 design}, based on Hoare's algebra of Communicating
                 Sequential Processes (CSP), and proposes that this
                 approach to concurrency leads to solutions that are
                 manageable by novice programmers; that is, they are
                 easy to design and maintain, that they are scalable for
                 complexity, {\em obviously correct}, and relatively
                 easy to verify using formal reasoning and/or model
                 checkers. These solutions can be developed in
                 conventional programming languages (through CSP
                 libraries) or specialized ones (such as occam-$ \pi $)
                 in a manner that directly reflects their formal
                 expression. Systems can be developed without needing
                 specialist knowledge of the CSP formalism, since the
                 supporting mathematics is burnt into the tools and
                 languages supporting it. We illustrate these concepts
                 with the {\em Santa Claus problem}, which has been used
                 as a challenge for concurrency mechanisms since 1994.
                 We consider this problem as an example control system,
                 producing external signals reporting changes of
                 internal state (that model the external world). We
                 claim our occam-$ \pi $ solution is {\em
                 correct-by-design}, but follow this up with formal
                 verification (using the FDR model checker for CSP) that
                 the system is free from deadlock and livelock, that the
                 produced control signals obey crucial ordering
                 constraints, and that the system has key liveness
                 properties.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency; CSP; deadlock; event ordering; liveness;
                 novice programmer; occam-pi; Process orientation;
                 verification",
}

@Article{Huang:2010:DBR,
  author =       "Yuqiang Huang and Bruce R. Childers and Mary Lou
                 Soffa",
  title =        "Detecting bugs in register allocation",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "4",
  pages =        "15:1--15:36",
  month =        apr,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1734206.1734212",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:47:03 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Although register allocation is critical for
                 performance, the implementation of register allocation
                 algorithms is difficult, due to the complexity of the
                 algorithms and target machine architectures. It is
                 particularly difficult to detect register allocation
                 errors if the output code runs to completion, as bugs
                 in the register allocator can cause the compiler to
                 produce incorrect output code. The output code may even
                 execute properly on some test data, but errors can
                 remain. In this article, we propose novel data flow
                 analyses to statically check that the value flow of the
                 output code from the register allocator is the same as
                 the value flow of its input code. The approach is
                 accurate, fast, and can identify and report error
                 locations and types. It is independent of the register
                 allocator and uses only the input and output code of
                 the register allocator. It can be used with different
                 register allocators, including those that perform
                 coalescing and rematerialization. The article describes
                 our approach, called SARAC, and a tool that statically
                 checks a register allocation and reports the errors and
                 their types that it finds. The tool has an average
                 compile-time overhead of only 8\% and a modest average
                 memory overhead of 85KB. Our techniques can be used by
                 compiler developers during regression testing and as a
                 command-line-enabled debugging pass for mysterious
                 compiler behavior.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Register allocation",
}

@Article{Kobayashi:2010:HTS,
  author =       "Naoki Kobayashi and Davide Sangiorgi",
  title =        "A hybrid type system for lock-freedom of mobile
                 processes",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "5",
  pages =        "16:1--16:49",
  month =        may,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1745312.1745313",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:28:30 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose a type system for lock-freedom in the $ \pi
                 $-calculus, which guarantees that certain
                 communications will eventually succeed. Distinguishing
                 features of our type system are: it can verify
                 lock-freedom of concurrent programs that have
                 sophisticated recursive communication structures; it
                 can be fully automated; it is hybrid, in that it
                 combines a type system for lock-freedom with local
                 reasoning about deadlock-freedom, termination, and
                 confluence analyses. Moreover, the type system is
                 parameterized by deadlock-freedom\slash
                 termination\slash confluence analyses, so that any
                 methods (e.g. type systems and model checking) can be
                 used for those analyses. A lock-freedom analysis tool
                 has been implemented based on the proposed type system,
                 and tested for nontrivial programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "concurrency; mobile processes; Type systems",
}

@Article{Jeffrey:2010:ESA,
  author =       "Dennis Jeffrey and Vijay Nagarajan and Rajiv Gupta and
                 Neelam Gupta",
  title =        "Execution suppression: an automated iterative
                 technique for locating memory errors",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "5",
  pages =        "17:1--17:36",
  month =        may,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1745312.1745314",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:28:30 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "By studying the behavior of several programs that
                 crash due to memory errors, we observed that locating
                 the errors can be challenging because significant
                 propagation of corrupt memory values can occur prior to
                 the point of the crash. In this article, we present an
                 automated approach for locating memory errors in the
                 presence of memory corruption propagation. Our approach
                 leverages the information revealed by a program crash:
                 when a crash occurs, this reveals a subset of the
                 memory corruption that exists in the execution. By
                 suppressing (nullifying) the effect of this known
                 corruption during execution, the crash is avoided and
                 any remaining (hidden) corruption may then be exposed
                 by subsequent crashes. The newly exposed corruption can
                 then be suppressed in turn. By iterating this process
                 until no further crashes occur, the first point of
                 memory corruption --- and the likely root cause of the
                 program failure --- can be identified. However, this
                 iterative approach may terminate prematurely, since
                 programs may not crash even when memory corruption is
                 present during execution. To address this, we show how
                 crashes can be exposed in an execution by manipulating
                 the relative ordering of particular variables within
                 memory. By revealing crashes through this variable
                 re-ordering, the effectiveness and applicability of the
                 execution suppression approach can be improved. We
                 describe a set of experiments illustrating the
                 effectiveness of our approach in consistently and
                 precisely identifying the first points of memory
                 corruption in executions that fail due to memory
                 errors. We also discuss a baseline software
                 implementation of execution suppression that incurs an
                 average overhead of 7.2x, and describe how to reduce
                 this overhead to 1.8x through hardware support.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Execution suppression; fault localization; hardware
                 support; memory corruption propagation; memory errors;
                 variable re-ordering",
}

@Article{Yahav:2010:VSP,
  author =       "Eran Yahav and Mooly Sagiv",
  title =        "Verifying safety properties of concurrent
                 heap-manipulating programs",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "5",
  pages =        "18:1--18:50",
  month =        may,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1745312.1745315",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:28:30 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We provide a parametric framework for verifying safety
                 properties of concurrent heap-manipulating programs.
                 The framework combines thread-scheduling information
                 with information about the shape of the heap. This
                 leads to verification algorithms that are more precise
                 than existing techniques. The framework also provides a
                 precise shape-analysis algorithm for concurrent
                 programs. In contrast to most existing verification
                 techniques, we do not put a bound on the number of
                 allocated objects. The framework produces interesting
                 results even when analyzing programs with an unbounded
                 number of threads. The framework is applied to
                 successfully verify the following properties of a
                 concurrent program:\par

                 --- Concurrent manipulation of linked-list based ADT
                 preserves the ADT datatype invariant.\par

                 --- The program does not perform inconsistent updates
                 due to interference.\par

                 --- The program does not reach a deadlock.\par

                 --- The program does not produce runtime errors due to
                 illegal thread interactions.\par

                 We also found bugs in erroneous programs violating such
                 properties. A prototype of our framework has been
                 implemented and applied to small, but interesting,
                 example programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Abstract interpretation; concurrency; Java; safety
                 properties; shape-analysis; verification",
}

@Article{Apel:2010:CUF,
  author =       "Sven Apel and Delesley Hutchins",
  title =        "A calculus for uniform feature composition",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "5",
  pages =        "19:1--19:33",
  month =        may,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1745312.1745316",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri May 21 12:28:30 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The goal of {\em feature-oriented programming\/} (FOP)
                 is to modularize software systems in terms of features.
                 A {\em feature\/} refines the content of a base
                 program. Both base programs and features may contain
                 various kinds of software artifacts, for example,
                 source code in different languages, models, build
                 scripts, and documentation. We and others have noticed
                 that when composing features, different kinds of
                 software artifacts can be refined in a uniform way,
                 regardless of what they represent. We present gDeep, a
                 core calculus for feature composition, which captures
                 the language independence of FOP; it can be used to
                 compose features containing many different kinds of
                 artifact in a type-safe way. The calculus allows us to
                 gain insight into the principles of FOP and to define
                 general algorithms for feature composition and
                 validation. We provide the formal syntax, operational
                 semantics, and type system of gDeep and outline how
                 languages like Java, Haskell, Bali, and XML can be
                 plugged in.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "feature composition; Feature-oriented programming;
                 principle of uniformity; type systems",
}

@Article{Mckinley:2010:PVT,
  author =       "Kathryn S. Mckinley and Keshav Pingali",
  title =        "La prossima vita at {TOPLAS}",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "6",
  pages =        "20:1--20:1",
  month =        aug,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1749608.1749609",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 8 18:52:47 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ruggieri:2010:TLC,
  author =       "Salvatore Ruggieri and Fred Mesnard",
  title =        "Typing linear constraints",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "6",
  pages =        "21:1--21:42",
  month =        aug,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1749608.1749610",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 8 18:52:47 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a type system for linear constraints over
                 the reals intended for reasoning about the input-output
                 directionality of variables. Types model the properties
                 of definiteness, range width or approximation, lower
                 and upper bounds of variables in a linear constraint.
                 Several proof procedures are presented for inferring
                 the type of a variable and for checking validity of
                 type assertions. We rely on theory and tools for linear
                 programming problems, linear algebra, parameterized
                 polyhedra and negative constraints. An application of
                 the type system is proposed in the context of the
                 static analysis of constraint logic programs. Type
                 assertions are at the basis of the extension of
                 well-moding from pure logic programming. The proof
                 procedures (both for type assertion validity and for
                 well-moding) are implemented and their computational
                 complexity is discussed. We report experimental results
                 demonstrating the efficiency in practice of the
                 proposed approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "constraint logic programming; definiteness; Linear
                 constraints; polyhedra; well-moding",
}

@Article{Boyland:2010:SFP,
  author =       "John Tang Boyland",
  title =        "Semantics of fractional permissions with nesting",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "6",
  pages =        "22:1--22:33",
  month =        aug,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1749608.1749611",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 8 18:52:47 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Permissions specify mutable state that can be accessed
                 by a program. Fractions distinguish write access (1)
                 from read access (any smaller fraction). Nesting can
                 model object invariants and ownership. Fractional
                 permissions provides a foundation the meaning of many
                 of access-based annotations: uniqueness, read-only,
                 immutability, method effects, guarded state, etc. The
                 semantics of fractional permissions with nesting is
                 given in terms of ``fractional heaps.'' We show that
                 the fraction law $ \Pi \equiv 1 / 2 \Pi + 1 / 2 \Pi $
                 permits sound reasoning and that nesting can be carried
                 out safely using only local reasoning.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Balakrishnan:2010:WWY,
  author =       "Gogul Balakrishnan and Thomas Reps",
  title =        "{WYSINWYX}: {What} you see is not what you {eXecute}",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "6",
  pages =        "23:1--23:84",
  month =        aug,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1749608.1749612",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 8 18:52:47 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Over the last seven years, we have developed
                 static-analysis methods to recover a good approximation
                 to the variables and dynamically allocated memory
                 objects of a stripped executable, and to track the flow
                 of values through them. The article presents the
                 algorithms that we developed, explains how they are
                 used to recover Intermediate Representations (IRs) from
                 executables that are similar to the IRs that would be
                 available if one started from source code, and
                 describes their application in the context of program
                 understanding and automated bug hunting.\par

                 Unlike algorithms for analyzing executables that
                 existed prior to our work, the ones presented in this
                 article provide useful information about memory
                 accesses, even in the absence of debugging information.
                 The ideas described in the article are incorporated in
                 a tool for analyzing Intel x86 executables, called
                 CodeSurfer/x86. CodeSurfer/x86 builds a system
                 dependence graph for the program, and provides a GUI
                 for exploring the graph by (i) navigating its edges,
                 and (ii) invoking operations, such as forward slicing,
                 backward slicing, and chopping, to discover how parts
                 of the program can impact other parts.\par

                 To assess the usefulness of the IRs recovered by
                 CodeSurfer/x86 in the context of automated bug hunting,
                 we built a tool on top of CodeSurfer/x86, called
                 Device-Driver Analyzer for x86 (DDA/x86), which
                 analyzes device-driver executables for bugs. Without
                 the benefit of either source code or
                 symbol-table/debugging information, DDA/x86 was able to
                 find known bugs (that had been discovered previously by
                 source-code analysis tools), along with useful error
                 traces, while having a low false-positive rate. DDA/x86
                 is the first known application of program
                 analysis/verification techniques to industrial
                 executables.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "Abstract interpretation; context-sensitive analysis;
                 data structure recovery; interprocedural dataflow
                 analysis; pointer analysis; reverse engineering; static
                 analysis",
}

@Article{Reps:2010:FDL,
  author =       "Thomas Reps and Mooly Sagiv and Alexey Loginov",
  title =        "Finite differencing of logical formulas for static
                 analysis",
  journal =      j-TOPLAS,
  volume =       "32",
  number =       "6",
  pages =        "24:1--24:55",
  month =        aug,
  year =         "2010",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1749608.1749613",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Sep 8 18:52:47 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article concerns mechanisms for maintaining the
                 value of an instrumentation relation (also known as a
                 {\em derived relation\/} or {\em view\/}), defined via
                 a logical formula over core relations, in response to
                 changes in the values of the core relations. It
                 presents an algorithm for transforming the
                 instrumentation relation's defining formula into a {\em
                 relation-maintenance formula\/} that captures what the
                 instrumentation relation's new value should be. The
                 algorithm runs in time linear in the size of the
                 defining formula.\par

                 The technique applies to program analysis problems in
                 which the semantics of statements is expressed using
                 logical formulas that describe changes to core relation
                 values. It provides a way to obtain values of the
                 instrumentation relations that reflect the changes in
                 core relation values produced by executing a given
                 statement.\par

                 We present experimental evidence that our technique is
                 an effective one: for a variety of benchmarks, the
                 relation-maintenance formulas produced automatically
                 using our approach yield the same precision as the best
                 available hand-crafted ones.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
  keywords =     "3 - valued logic; Abstract interpretation; finite
                 differencing; materialized view; shape analysis; static
                 analysis",
}

@Article{Palsberg:2011:E,
  author =       "Jens Palsberg",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "1",
  pages =        "1:1--1:1",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1889997.1889998",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 26 14:45:44 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Abadi:2011:STM,
  author =       "Mart{\'\i}n Abadi and Andrew Birrell and Tim Harris
                 and Michael Isard",
  title =        "Semantics of transactional memory and automatic mutual
                 exclusion",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "1",
  pages =        "2:1--2:50",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1889997.1889999",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 26 14:45:44 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Software Transactional Memory (STM) is an attractive
                 basis for the development of language features for
                 concurrent programming. However, the semantics of these
                 features can be delicate and problematic. In this
                 article we explore the trade-offs semantic simplicity,
                 the viability of efficient implementation strategies,
                 and the flexibility of language constructs.
                 Specifically, we develop semantics and type systems for
                 the constructs of the Automatic Mutual Exclusion (AME)
                 programming model; our results apply also to other
                 constructs, such as atomic blocks. With this semantics
                 as a point of reference, we study several
                 implementation strategies. We model STM systems that
                 use in-place update, optimistic concurrency, lazy
                 conflict detection, and rollback.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Pratikakis:2011:LPS,
  author =       "Polyvios Pratikakis and Jeffrey S. Foster and Michael
                 Hicks",
  title =        "{LOCKSMITH}: {Practical} static race detection for
                 {C}",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "1",
  pages =        "3:1--3:55",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1889997.1890000",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 26 14:45:44 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Locksmith is a static analysis tool for automatically
                 detecting data races in C programs. In this article, we
                 describe each of Locksmith's component analyses
                 precisely, and present systematic measurements that
                 isolate interesting trade-offs between precision and
                 efficiency in each analysis. Using a benchmark suite
                 comprising stand-alone applications and Linux device
                 drivers totaling more than 200,000 lines of code, we
                 found that a simple no-worklist strategy yielded the
                 most efficient interprocedural dataflow analysis; that
                 our sharing analysis was able to determine that most
                 locations are thread-local, and therefore need not be
                 protected by locks; that modeling C structs and void
                 pointers precisely is key to both precision and
                 efficiency; and that context sensitivity yields a much
                 more precise analysis, though with decreased
                 scalability.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Derrick:2011:MVP,
  author =       "John Derrick and Gerhard Schellhorn and Heike
                 Wehrheim",
  title =        "Mechanically verified proof obligations for
                 linearizability",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "1",
  pages =        "4:1--4:43",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1889997.1890001",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 26 14:45:44 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Concurrent objects are inherently complex to verify.
                 In the late 80s and early 90s, Herlihy and Wing
                 proposed linearizability as a correctness condition for
                 concurrent objects, which, once proven, allows us to
                 reason about concurrent objects using pre- and
                 postconditions only. A concurrent object is
                 linearizable if all of its operations appear to take
                 effect instantaneously some time between their
                 invocation and return. In this article we define
                 simulation-based proof conditions for linearizability
                 and apply them to two concurrent implementations, a
                 lock-free stack and a set with lock-coupling. Similar
                 to other approaches, we employ a theorem prover (here,
                 KIV) to mechanize our proofs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sangiorgi:2011:EBH,
  author =       "Davide Sangiorgi and Naoki Kobayashi and Eijiro
                 Sumii",
  title =        "Environmental bisimulations for higher-order
                 languages",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "1",
  pages =        "5:1--5:69",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1889997.1890002",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 26 14:45:44 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Developing a theory of bisimulation in higher-order
                 languages can be hard. Particularly challenging can be:
                 (1) the proof of congruence, as well as enhancements of
                 the bisimulation proof method with ``up-to context''
                 techniques, and (2) obtaining definitions and results
                 that scale to languages with different features. To
                 meet these challenges, we present environment
                 bisimulations, a form of bisimulation for higher-order
                 languages, and its basic theory. We consider four
                 representative calculi: pure $ \lambda $-calculi
                 (call-by-name and call-by-value), call-by-value $
                 \lambda $-calculus with higher-order store, and then
                 Higher-Order $ \pi $-calculus. In each case: we present
                 the basic properties of environment bisimilarity,
                 including congruence; we show that it coincides with
                 contextual equivalence; we develop some up-to
                 techniques, including up-to context, as examples of
                 possible enhancements of the associated bisimulation
                 method.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Huang:2011:MSS,
  author =       "Shan Shan Huang and Yannis Smaragdakis",
  title =        "Morphing: Structurally shaping a class by reflecting
                 on others",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "2",
  pages =        "6:1--6:44",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1890028.1890029",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 17 19:28:29 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Giesl:2011:ATP,
  author =       "J{\"u}rgen Giesl and Matthias Raffelsieper and Peter
                 Schneider-Kamp and Stephan Swiderski and Ren{\'e}
                 Thiemann",
  title =        "Automated termination proofs for {Haskell} by term
                 rewriting",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "2",
  pages =        "7:1--7:39",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1890028.1890030",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 17 19:28:29 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bengtson:2011:RTS,
  author =       "Jesper Bengtson and Karthikeyan Bhargavan and
                 C{\'e}dric Fournet and Andrew D. Gordon and Sergio
                 Maffeis",
  title =        "Refinement types for secure implementations",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "2",
  pages =        "8:1--8:45",
  month =        jan,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1890028.1890031",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 17 19:28:29 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tip:2011:RUT,
  author =       "Frank Tip and Robert M. Fuhrer and Adam Kie{\.z}un and
                 Michael D. Ernst and Ittai Balaban and Bjorn {De
                 Sutter}",
  title =        "Refactoring using type constraints",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "3",
  pages =        "9:1--9:47",
  month =        apr,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1961204.1961205",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 10:01:42 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Type constraints express subtype relationships between
                 the types of program expressions, for example, those
                 relationships that are required for type correctness.
                 Type constraints were originally proposed as a
                 convenient framework for solving type checking and type
                 inference problems. This paper shows how type
                 constraints can be used as the basis for practical
                 refactoring tools. In our approach, a set of type
                 constraints is derived from a type-correct program P.
                 The main insight behind our work is the fact that P
                 constitutes just one solution to this constraint
                 system, and that alternative solutions may exist that
                 correspond to refactored versions of P.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Banerjee:2011:MFT,
  author =       "Utpal Banerjee",
  title =        "Mathematical foundation of trace scheduling",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "3",
  pages =        "10:1--10:24",
  month =        apr,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1961204.1961206",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 10:01:42 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Since its introduction by Joseph A. Fisher in 1979,
                 trace scheduling has influenced much of the work on
                 compile-time ILP (Instruction Level Parallelism)
                 transformations. Initially developed for use in
                 microcode compaction, it quickly became the main
                 technique for machine-level compile-time parallelism
                 exploitation. Although it has been used since the 1980s
                 in many state-of-the-art compilers (e.g., Intel,
                 Fujitsu, HP), a rigorous theory of trace scheduling is
                 still lacking in the existing literature. This is
                 reflected in the ad hoc way compensation code is
                 inserted after a trace compaction, in the total absence
                 of any attempts to measure the size of that
                 compensation code, and so on.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gawlitza:2011:SSR,
  author =       "Thomas Martin Gawlitza and Helmut Seidl",
  title =        "Solving systems of rational equations through strategy
                 iteration",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "3",
  pages =        "11:1--11:48",
  month =        apr,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1961204.1961207",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 10:01:42 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present practical algorithms for computing exact
                 least solutions of equation systems over the reals with
                 addition, multiplication by positive constants, minimum
                 and maximum. The algorithms are based on strategy
                 iteration. Our algorithms can, for instance, be used
                 for the analysis of recursive stochastic games. In the
                 present article we apply our techniques for computing
                 abstract least fixpoint semantics of affine programs
                 over the relational template polyhedra domain. In
                 particular, we thus obtain practical algorithms for
                 computing abstract least fixpoint semantics over the
                 abstract domains of intervals, zones, and octagons.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wehr:2011:JIT,
  author =       "Stefan Wehr and Peter Thiemann",
  title =        "{JavaGI}: The Interaction of Type Classes with
                 Interfaces and Inheritance",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "4",
  pages =        "12:1--12:83",
  month =        jul,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1985342.1985343",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 18 12:33:22 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The language JavaGI extends Java 1.5 conservatively by
                 a generalized interface mechanism. The generalization
                 subsumes retroactive and type-conditional interface
                 implementations, binary methods, symmetric multiple
                 dispatch, interfaces over families of types, and static
                 interface methods. These features make certain coding
                 patterns redundant, increase the expressiveness of the
                 type system, and permit solutions to extension and
                 integration problems with components in binary form,
                 for which previously several unrelated extensions had
                 been suggested. This article explains JavaGI and
                 motivates its design. Moreover, it formalizes a core
                 calculus for JavaGI and proves type soundness,
                 decidability of typechecking, and determinacy of
                 evaluation. The article also presents the
                 implementation of a JavaGI compiler and an accompanying
                 run-time system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barthe:2011:AMC,
  author =       "Gilles Barthe and C{\'e}sar Kunz",
  title =        "An Abstract Model of Certificate Translation",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "4",
  pages =        "13:1--13:46",
  month =        jul,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1985342.1985344",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 18 12:33:22 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A certificate is a mathematical object that can be
                 used to establish that a piece of mobile code satisfies
                 some security policy. In general, certificates cannot
                 be generated automatically. There is thus an interest
                 in developing methods to reuse certificates generated
                 for source code to provide strong guarantees of the
                 compiled code correctness. Certificate translation is a
                 method to transform certificates of program correctness
                 along semantically justified program transformations.
                 These methods have been developed in previous work, but
                 they were strongly dependent on particular programming
                 and verification settings.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tripakis:2011:TSR,
  author =       "Stavros Tripakis and Ben Lickly and Thomas A.
                 Henzinger and Edward A. Lee",
  title =        "A Theory of Synchronous Relational Interfaces",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "4",
  pages =        "14:1--14:41",
  month =        jul,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/1985342.1985345",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 18 12:33:22 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Compositional theories are crucial when designing
                 large and complex systems from smaller components. In
                 this work we propose such a theory for synchronous
                 concurrent systems. Our approach follows so-called
                 interface theories, which use game-theoretic
                 interpretations of composition and refinement. These
                 are appropriate for systems with distinct inputs and
                 outputs, and explicit conditions on inputs that must be
                 enforced during composition. Our interfaces model
                 systems that execute in an infinite sequence of
                 synchronous rounds. At each round, a contract must be
                 satisfied. The contract is simply a relation specifying
                 the set of valid input/output pairs. Interfaces can be
                 composed by parallel, serial or feedback composition.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alur:2011:SMC,
  author =       "Rajeev Alur and Swarat Chaudhuri and P. Madhusudan",
  title =        "Software model checking using languages of nested
                 trees",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "5",
  pages =        "15:1--15:45",
  month =        nov,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2039346.2039347",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Dec 19 15:55:36 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "While model checking of pushdown systems is by now an
                 established technique in software verification,
                 temporal logics and automata traditionally used in this
                 area are unattractive on two counts. First, logics and
                 automata traditionally used in model checking cannot
                 express requirements such as pre/post-conditions that
                 are basic to analysis of software. Second, unlike in
                 the finite-state world, where the $ \mu $-calculus has
                 a symbolic model-checking algorithm and serves as an
                 ``assembly language'' to which temporal logics can be
                 compiled, there is no common formalism---either
                 fixpoint-based or automata-theoretic---to model-check
                 requirements on pushdown models. In this article, we
                 introduce a new theory of temporal logics and automata
                 that addresses the above issues, and provides a unified
                 foundation for the verification of pushdown systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dimoulas:2011:CSH,
  author =       "Christos Dimoulas and Matthias Felleisen",
  title =        "On contract satisfaction in a higher-order world",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "5",
  pages =        "16:1--16:29",
  month =        nov,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2039346.2039348",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Dec 19 15:55:36 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Behavioral software contracts have become a popular
                 mechanism for specifying and ensuring logical claims
                 about a program's flow of values. While contracts for
                 first-order functions come with a natural
                 interpretation and are well understood, the various
                 incarnations of higher-order contracts adopt,
                 implicitly or explicitly, different views concerning
                 the meaning of contract satisfaction. In this article,
                 we define various notions of contract satisfaction in
                 terms of observational equivalence and compare them
                 with each other and notions in the literature.
                 Specifically, we introduce a small model language with
                 higher-order contracts and use it to formalize
                 different notions of contract satisfaction.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gulavani:2011:BSA,
  author =       "Bhargav S. Gulavani and Supratik Chakraborty and G.
                 Ramalingam and Aditya V. Nori",
  title =        "Bottom-up shape analysis using {LISF}",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "5",
  pages =        "17:1--17:41",
  month =        nov,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2039346.2039349",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Dec 19 15:55:36 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article, we present a new shape analysis
                 algorithm. The key distinguishing aspect of our
                 algorithm is that it is completely compositional,
                 bottom-up and noniterative. We present our algorithm as
                 an inference system for computing Hoare triples
                 summarizing heap manipulating programs. Our inference
                 rules are compositional: Hoare triples for a compound
                 statement are computed from the Hoare triples of its
                 component statements. These inference rules are used as
                 the basis for bottom-up shape analysis of programs.
                 Specifically, we present a Logic of Iterated Separation
                 Formulae (LISF), which uses the iterated separating
                 conjunct of Reynolds [2002] to represent program
                 states. A key ingredient of our inference rules is a
                 strong bi-abduction operation between two logical
                 formulas.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Palsberg:2011:EN,
  author =       "Jens Palsberg",
  title =        "Editorial note",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "6",
  pages =        "18:1--18:1",
  month =        dec,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2049706.2049707",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Dec 29 16:28:40 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ying:2011:FHL,
  author =       "Mingsheng Ying",
  title =        "{Floyd--Hoare} logic for quantum programs",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "6",
  pages =        "19:1--19:49",
  month =        dec,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2049706.2049708",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Dec 29 16:28:40 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Floyd--Hoare logic is a foundation of axiomatic
                 semantics of classical programs, and it provides
                 effective proof techniques for reasoning about
                 correctness of classical programs. To offer similar
                 techniques for quantum program verification and to
                 build a logical foundation of programming methodology
                 for quantum computers, we develop a full-fledged
                 Floyd--Hoare logic for both partial and total
                 correctness of quantum programs. It is proved that this
                 logic is (relatively) complete by exploiting the power
                 of weakest preconditions and weakest liberal
                 preconditions for quantum programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dietl:2011:SOT,
  author =       "Werner Dietl and Sophia Drossopoulou and Peter
                 M{\"u}ller",
  title =        "Separating ownership topology and encapsulation with
                 generic universe types",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "6",
  pages =        "20:1--20:62",
  month =        dec,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2049706.2049709",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Dec 29 16:28:40 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Ownership is a powerful concept to structure the
                 object store and to control aliasing and modifications
                 of objects. This article presents an ownership type
                 system for a Java-like programming language with
                 generic types. Like our earlier Universe type system,
                 Generic Universe Types structure the heap
                 hierarchically. In contrast to earlier work, we
                 separate the enforcement of an ownership topology from
                 an encapsulation system. The topological system uses an
                 existential modifier to express that no ownership
                 information is available statically. On top of the
                 topological system, we build an encapsulation system
                 that enforces the owner-as-modifier discipline. This
                 discipline does not restrict aliasing, but requires
                 modifications of an object to be initiated by its
                 owner.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Flexeder:2011:FIL,
  author =       "Andrea Flexeder and Markus M{\"u}ller-olm and Michael
                 Petter and Helmut Seidl",
  title =        "Fast interprocedural linear two-variable equalities",
  journal =      j-TOPLAS,
  volume =       "33",
  number =       "6",
  pages =        "21:1--21:33",
  month =        dec,
  year =         "2011",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2049706.2049710",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Dec 29 16:28:40 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article we provide an interprocedural analysis
                 of linear two-variable equalities. The novel algorithm
                 has a worst-case complexity of $ O(n, k^4) $, where $k$
                 is the number of variables and $n$ is the program size.
                 Thus, it saves a factor of $ k^4$ in comparison to a
                 related algorithm based on full linear algebra. We also
                 indicate how the practical runtime can be further
                 reduced significantly.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Palsberg:2012:E,
  author =       "Jens Palsberg",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "1:1--1:1",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2180860",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "TOPLAS will have four issues per year from now on! The
                 goal is to have each of the four issues contain 5--6
                 articles, instead of the previous schedule of six
                 issues that each typically contained 3--4 articles.
                 Historically, TOPLAS had four issues per volume from
                 1980 to 1992, and all but three of those issues
                 contained 5 or more articles. I hope that the TOPLAS
                 readers will enjoy the fewer, thicker issues of TOPLAS.
                 I thank the associate editors who continue to serve
                 TOPLAS, and I also thank Wei Li and Aaron Stump who in
                 the Winter of 2012 reached the end of their terms and
                 stepped down as associate editors. Welcome to Michael
                 Hicks who is a new associate editor.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Smans:2012:IDF,
  author =       "Jan Smans and Bart Jacobs and Frank Piessens",
  title =        "Implicit dynamic frames",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "2:1--2:58",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2160911",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "An important, challenging problem in the verification
                 of imperative programs with shared, mutable state is
                 the frame problem in the presence of data abstraction.
                 That is, one must be able to specify and verify upper
                 bounds on the set of memory locations a method can read
                 and write without exposing that method's
                 implementation. Separation logic is now widely
                 considered the most promising solution to this problem.
                 However, unlike conventional verification approaches,
                 separation logic assertions cannot mention
                 heap-dependent expressions from the host programming
                 language, such as method calls familiar to many
                 developers. Moreover, separation logic-based verifiers
                 are often based on symbolic execution. These symbolic
                 execution-based verifiers typically do not support
                 non-separating conjunction, and some of them rely on
                 the developer to explicitly fold and unfold predicate
                 definitions. Furthermore, several researchers have
                 wondered whether it is possible to use verification
                 condition generation and standard first-order provers
                 instead of symbolic execution to automatically verify
                 conformance with a separation logic specification. In
                 this article, we propose a variant of separation logic
                 called implicit dynamic frames that supports
                 heap-dependent expressions inside assertions.
                 Conformance with an implicit dynamic frames
                 specification can be checked by proving the validity of
                 a number of first-order verification conditions. To
                 show that these verification conditions can be
                 discharged automatically by standard first-order
                 provers, we have implemented our approach in a verifier
                 prototype and have used this prototype to verify
                 several challenging examples from related work. Our
                 prototype automatically folds and unfolds predicate
                 definitions, as required, during the proof and can
                 reason about non-separating conjunction which is used
                 in the specifications of some of these examples.
                 Finally, we prove the soundness of the approach.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Renganarayanan:2012:PLT,
  author =       "Lakshminarayanan Renganarayanan and Daegon Kim and
                 Michelle Mills Strout and Sanjay Rajopadhye",
  title =        "Parameterized loop tiling",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "3:1--3:41",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2160912",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Loop tiling is a widely used program optimization that
                 improves data locality and enables coarse-grained
                 parallelism. Parameterized tiled loops, where the tile
                 sizes remain symbolic parameters until runtime, are
                 quite useful for iterative compilers and autotuners
                 that produce highly optimized libraries and codes.
                 Although it is easy to generate such loops for (hyper-)
                 rectangular iteration spaces tiled with (hyper-)
                 rectangular tiles, many important computations do not
                 fall into this restricted domain. In the past,
                 parameterized tiled code generation for the general
                 case of convex iteration spaces being tiled by (hyper-)
                 rectangular tiles has been solved with bounding box
                 approaches or with sophisticated and expensive
                 machinery. We present a novel formulation of the
                 parameterized tiled loop generation problem using a
                 polyhedral set called the outset. By reducing the
                 problem of parameterized tiled code generation to that
                 of generating standard loops and simple postprocessing
                 of these loops, the outset method achieves a code
                 generation efficiency that is comparable to existing
                 code generation techniques, including those for fixed
                 tile sizes. We compare the performance of our technique
                 with several other tiled loop generation methods on
                 kernels from BLAS3 and scientific computations. The
                 simplicity of our solution makes it well suited for use
                 in production compilers-in particular, the IBM XL
                 compiler uses the inset-based technique introduced in
                 this article for register tiling. We also provide a
                 complete coverage of parameterized tiling of perfect
                 loop nests by describing three related techniques: (i)
                 a scheme for separating full and partial tiles; (ii) a
                 scheme for generating tiled loops directly from the
                 abstract syntax tree representation of loops; (iii) a
                 formal characterization of parameterized loop tiling
                 using bilinear forms and a Symbolic Fourier-Motzkin
                 Elimination (SFME)-based parameterized tiled loop
                 generation method.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dolby:2012:DCA,
  author =       "Julian Dolby and Christian Hammer and Daniel Marino
                 and Frank Tip and Mandana Vaziri and Jan Vitek",
  title =        "A data-centric approach to synchronization",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "4:1--4:48",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2160913",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Concurrency-related errors, such as data races, are
                 frustratingly difficult to track down and eliminate in
                 large object-oriented programs. Traditional approaches
                 to preventing data races rely on protecting instruction
                 sequences with synchronization operations. Such
                 control-centric approaches are inherently brittle, as
                 the burden is on the programmer to ensure that all
                 concurrently accessed memory locations are consistently
                 protected. Data-centric synchronization is an
                 alternative approach that offloads some of the work on
                 the language implementation. Data-centric
                 synchronization groups fields of objects into atomic
                 sets to indicate that these fields must always be
                 updated atomically. Each atomic set has associated
                 units of work, that is, code fragments that preserve
                 the consistency of that atomic set. Synchronization
                 operations are added automatically by the compiler. We
                 present an extension to the Java programming language
                 that integrates annotations for data-centric
                 concurrency control. The resulting language, called AJ,
                 relies on a type system that enables separate
                 compilation and supports atomic sets that span multiple
                 objects and that also supports full encapsulation for
                 more efficient code generation. We evaluate our
                 proposal by refactoring classes from standard
                 libraries, as well as a number of multithreaded
                 benchmarks, to use atomic sets. Our results suggest
                 that data-centric synchronization is easy to use and
                 enjoys low annotation overhead, while successfully
                 preventing data races. Moreover, experiments on the
                 SPECjbb benchmark suggest that acceptable performance
                 can be achieved with a modest amount of tuning.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wu:2012:STB,
  author =       "Xing Wu and Frank Mueller",
  title =        "{ScalaExtrap}: {Trace-based} communication
                 extrapolation for {SPMD} programs",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "5:1--5:29",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2160914",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Performance modeling for scientific applications is
                 important for assessing potential application
                 performance and systems procurement in high-performance
                 computing (HPC). Recent progress on communication
                 tracing opens up novel opportunities for communication
                 modeling due to its lossless yet scalable trace
                 collection. Estimating the impact of scaling on
                 communication efficiency still remains nontrivial due
                 to execution-time variations and exposure to hardware
                 and software artifacts. This work contributes a
                 fundamentally novel modeling scheme. We synthetically
                 generate the application trace for large numbers of
                 nodes via extrapolation from a set of smaller traces.
                 We devise an innovative approach for topology
                 extrapolation of single program, multiple data (SPMD)
                 codes with stencil or mesh communication. Experimental
                 results show that the extrapolated traces precisely
                 reflect the communication behavior and the performance
                 characteristics at the target scale for both strong and
                 weak scaling applications. The extrapolated trace can
                 subsequently be (a) replayed to assess communication
                 requirements before porting an application, (b)
                 transformed to autogenerate communication benchmarks
                 for various target platforms, and (c) analyzed to
                 detect communication inefficiencies and scalability
                 limitations. To the best of our knowledge, rapidly
                 obtaining the communication behavior of parallel
                 applications at arbitrary scale with the availability
                 of timed replay, yet without actual execution of the
                 application, at this scale, is without precedence and
                 has the potential to enable otherwise infeasible system
                 simulation at the exascale level.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ganty:2012:AVA,
  author =       "Pierre Ganty and Rupak Majumdar",
  title =        "Algorithmic verification of asynchronous programs",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "1",
  pages =        "6:1--6:48",
  month =        apr,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2160910.2160915",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Apr 30 17:20:50 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Asynchronous programming is a ubiquitous systems
                 programming idiom for managing concurrent interactions
                 with the environment. In this style, instead of waiting
                 for time-consuming operations to complete, the
                 programmer makes a non-blocking call to the operation
                 and posts a callback task to a task buffer that is
                 executed later when the time-consuming operation
                 completes. A cooperative scheduler mediates the
                 interaction by picking and executing callback tasks
                 from the task buffer to completion (and these callbacks
                 can post further callbacks to be executed later).
                 Writing correct asynchronous programs is hard because
                 the use of callbacks, while efficient, obscures program
                 control flow. We provide a formal model underlying
                 asynchronous programs and study verification problems
                 for this model. We show that the safety verification
                 problem for finite-data asynchronous programs is
                 expspace-complete. We show that liveness verification
                 for finite-data asynchronous programs is decidable and
                 polynomial-time equivalent to Petri net reachability.
                 Decidability is not obvious, since even if the data is
                 finite-state, asynchronous programs constitute
                 infinite-state transition systems: both the program
                 stack for an executing task and the task buffer of
                 pending calls to tasks can be potentially unbounded.
                 Our main technical constructions are polynomial-time,
                 semantics-preserving reductions from asynchronous
                 programs to Petri nets and back. The first reduction
                 allows the use of algorithmic techniques on Petri nets
                 for the verification of asynchronous programs, and the
                 second allows lower bounds on Petri nets to apply also
                 to asynchronous programs. We also study several
                 extensions to the basic models of asynchronous programs
                 that are inspired by additional capabilities provided
                 by implementations of asynchronous libraries and
                 classify the decidability and undecidability of
                 verification questions on these extensions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bodden:2012:PEF,
  author =       "Eric Bodden and Patrick Lam and Laurie Hendren",
  title =        "Partially Evaluating Finite-State Runtime Monitors
                 Ahead of Time",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "2",
  pages =        "7:1--7:52",
  month =        jun,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2220365.2220366",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 29 17:33:40 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Finite-state properties account for an important class
                 of program properties, typically related to the order
                 of operations invoked on objects. Many library
                 implementations therefore include manually written
                 finite-state monitors to detect violations of
                 finite-state properties at runtime. Researchers have
                 recently proposed the explicit specification of
                 finite-state properties and automatic generation of
                 monitors from the specification. However, runtime
                 monitoring only shows the presence of violations, and
                 typically cannot prove their absence. Moreover,
                 inserting a runtime monitor into a program under test
                 can slow down the program by several orders of
                 magnitude. In this work, we therefore present a set of
                 four static whole-program analyses that partially
                 evaluate runtime monitors at compile time, with
                 increasing cost and precision. As we show,
                 ahead-of-time evaluation can often evaluate the monitor
                 completely statically. This may prove that the program
                 cannot violate the property on any execution or may
                 prove that violations do exist. In the remaining cases,
                 the partial evaluation converts the runtime monitor
                 into a residual monitor. This monitor only receives
                 events from program locations that the analyses failed
                 to prove irrelevant. This makes the residual monitor
                 much more efficient than a full monitor, while still
                 capturing all property violations at runtime. We
                 implemented the analyses in Clara, a novel framework
                 for the partial evaluation of AspectJ-based runtime
                 monitors, and validated our approach by applying Clara
                 to finite-state properties over several large-scale
                 Java programs. Clara proved that most of the programs
                 never violate our example properties. Some programs
                 required monitoring, but in those cases Clara could
                 often reduce the monitoring overhead to below 10\%. We
                 observed that several programs did violate the stated
                 properties.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Carbone:2012:SCC,
  author =       "Marco Carbone and Kohei Honda and Nobuko Yoshida",
  title =        "Structured Communication-Centered Programming for
                 {Web} Services",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "2",
  pages =        "8:1--8:78",
  month =        jun,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2220365.2220367",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 29 17:33:40 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article relates two different paradigms of
                 descriptions of communication behavior, one focusing on
                 global message flows and another on end-point
                 behaviors, using formal calculi based on session types.
                 The global calculus, which originates from a Web
                 service description language (W3C WS-CDL), describes an
                 interaction scenario from a vantage viewpoint; the
                 end-point calculus, an applied typed $ \pi $-calculus,
                 precisely identifies a local behavior of each
                 participant. We explore a theory of end-point
                 projection, by which we can map a global description to
                 its end-point counterparts preserving types and
                 dynamics. Three principles of well-structured
                 description and the type structures play a fundamental
                 role in the theory.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Joisha:2012:TTE,
  author =       "Pramod G. Joisha and Robert S. Schreiber and
                 Prithviraj Banerjee and Hans-J. Boehm and Dhruva R.
                 Chakrabarti",
  title =        "On a Technique for Transparently Empowering Classical
                 Compiler Optimizations on Multithreaded Code",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "2",
  pages =        "9:1--9:42",
  month =        jun,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2220365.2220368",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 29 17:33:40 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A large body of data-flow analyses exists for
                 analyzing and optimizing sequential code.
                 Unfortunately, much of it cannot be directly applied on
                 parallel code, for reasons of correctness. This article
                 presents a technique to automatically, aggressively,
                 yet safely apply sequentially-sound data-flow
                 transformations, without change, on shared-memory
                 programs. The technique is founded on the notion of
                 program references being ``siloed'' on certain
                 control-flow paths. Intuitively, siloed references are
                 free of interference from other threads within the
                 confines of such paths. Data-flow transformations can,
                 in general, be unblocked on siloed references. The
                 solution has been implemented in a widely used
                 compiler. Results on benchmarks from SPLASH-2 show that
                 performance improvements of up to 41\% are possible,
                 with an average improvement of 6\% across all the
                 tested programs over all thread counts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Boudol:2012:RAW,
  author =       "G{\'e}rard Boudol and Zhengqin Luo and Tamara Rezk and
                 Manuel Serrano",
  title =        "Reasoning about {Web} Applications: An Operational
                 Semantics for {HOP}",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "2",
  pages =        "10:1--10:40",
  month =        jun,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2220365.2220369",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 29 17:33:40 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose a small-step operational semantics to
                 support reasoning about Web applications written in the
                 multitier language HOP. The semantics covers both
                 server side and client side computations, as well as
                 their interactions, and includes creation of Web
                 services, distributed client-server communications,
                 concurrent evaluation of service requests at server
                 side, elaboration of HTML documents, DOM operations,
                 evaluation of script nodes in HTML documents and
                 actions from HTML pages at client side. We also model
                 the browser same origin policy (SOP) in the semantics.
                 We propose a safety property by which programs do not
                 get stuck due to a violation of the SOP and a type
                 system to enforce it.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Verdoolaege:2012:ECS,
  author =       "Sven Verdoolaege and Gerda Janssens and Maurice
                 Bruynooghe",
  title =        "Equivalence checking of static affine programs using
                 widening to handle recurrences",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "3",
  pages =        "11:1--11:35",
  month =        oct,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2362389.2362390",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 5 18:03:50 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Designers often apply manual or semi-automatic loop
                 and data transformations on array- and loop-intensive
                 programs to improve performance. It is crucial that
                 such transformations preserve the functionality of the
                 program. This article presents an automatic method for
                 constructing equivalence proofs for the class of static
                 affine programs. The equivalence checking is performed
                 on a dependence graph abstraction and uses a new
                 approach based on widening to find the proper induction
                 hypotheses for reasoning about recurrences. Unlike
                 transitive-closure-based approaches, this widening
                 approach can also handle nonuniform recurrences. The
                 implementation is publicly available and is the first
                 of its kind to fully support commutative operations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{DeFraine:2012:EAC,
  author =       "Bruno {De Fraine} and Erik Ernst and Mario
                 S{\"u}dholt",
  title =        "Essential {AOP}: {The} {$A$} calculus",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "3",
  pages =        "12:1--12:43",
  month =        oct,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2362389.2362391",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 5 18:03:50 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Aspect-oriented programming (AOP) has produced
                 interesting language designs, but also ad hoc semantics
                 that needs clarification. We contribute to this
                 clarification with a calculus that models essential
                 AOP, both simpler and more general than existing
                 formalizations. In AOP, advice may intercept method
                 invocations, and proceed executes the suspended call.
                 Proceed is an ad hoc mechanism, only usable inside
                 advice bodies. Many pointcut mechanisms, for example,
                 wildcards, also lack regularity. We model proceed using
                 first-class closures, and shift complexity from
                 pointcuts to ordinary object-oriented code. Two
                 well-known pointcut categories, call and execution, are
                 commonly considered similar. We formally expose their
                 differences, and resolve the associated soundness
                 problem. Our calculus includes type ranges, an
                 intuitive and concise alternative to explicit type
                 variables that allows advice to be polymorphic over
                 intercepted methods. We use calculus parameters to
                 cover type safety for a wide design space of other
                 features. Type soundness is verified in Coq.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bendersky:2012:SOB,
  author =       "Anna Bendersky and Erez Petrank",
  title =        "Space overhead bounds for dynamic memory management
                 with partial compaction",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "3",
  pages =        "13:1--13:43",
  month =        oct,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2362389.2362392",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 5 18:03:50 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Dynamic memory allocation is ubiquitous in today's
                 runtime environments. Allocation and deallocation of
                 objects during program execution may cause
                 fragmentation and foil the program's ability to
                 allocate objects. Robson [1971] has shown that a
                 worst-case scenario can create a space overhead within
                 a factor of log n of the space that is actually
                 required by the program, where n is the size of the
                 largest possible object. Compaction can eliminate
                 fragmentation, but is too costly to be run frequently.
                 Many runtime systems employ partial compaction, in
                 which only a small fraction of the allocated objects
                 are moved. Partial compaction reduces some of the
                 existing fragmentation at an acceptable cost. In this
                 article we study the effectiveness of partial
                 compaction and provide the first rigorous lower and
                 upper bounds on its effectiveness in reducing
                 fragmentation at a low cost.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hoffmann:2012:MAR,
  author =       "Jan Hoffmann and Klaus Aehlig and Martin Hofmann",
  title =        "Multivariate amortized resource analysis",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "3",
  pages =        "14:1--14:62",
  month =        oct,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2362389.2362393",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Nov 5 18:03:50 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We study the problem of automatically analyzing the
                 worst-case resource usage of procedures with several
                 arguments. Existing automatic analyses based on
                 amortization or sized types bound the resource usage or
                 result size of such a procedure by a sum of unary
                 functions of the sizes of the arguments. In this
                 article we generalize this to arbitrary multivariate
                 polynomial functions thus allowing bounds of the form $
                 m n $ which had to be grossly overestimated by $ m^2 +
                 n^2 $ before. Our framework even encompasses bounds
                 like $ \sum_{i, j \leq n} m_i m_j $ where the $ m_i $
                 are the sizes of the entries of a list of length $n$.
                 This allows us for the first time to derive useful
                 resource bounds for operations on matrices that are
                 represented as lists of lists and to considerably
                 improve bounds on other superlinear operations on lists
                 such as longest common subsequence and removal of
                 duplicates from lists of lists. Furthermore, resource
                 bounds are now closed under composition which improves
                 accuracy of the analysis of composed programs when some
                 or all of the components exhibit superlinear resource
                 or size behavior. The analysis is based on a novel
                 multivariate amortized resource analysis. We present it
                 in form of a type system for a simple first-order
                 functional language with lists and trees, prove
                 soundness, and describe automatic type inference based
                 on linear programming. We have experimentally validated
                 the automatic analysis on a wide range of examples from
                 functional programming with lists and trees. The
                 obtained bounds were compared with actual resource
                 consumption. All bounds were asymptotically tight, and
                 the constants were close or even identical to the
                 optimal ones.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{deJonge:2012:NFE,
  author =       "Maartje de Jonge and Lennart C. L. Kats and Eelco
                 Visser and Emma S{\"o}derberg",
  title =        "Natural and Flexible Error Recovery for Generated
                 Modular Language Environments",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "4",
  pages =        "15:1--15:50",
  month =        dec,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2400676.2400678",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 10 17:44:23 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Integrated Development Environments (IDEs) increase
                 programmer productivity, providing rapid, interactive
                 feedback based on the syntax and semantics of a
                 language. Unlike conventional parsing algorithms,
                 scannerless generalized-LR parsing supports the full
                 set of context-free grammars, which is closed under
                 composition, and hence can parse languages composed
                 from separate grammar modules. To apply this algorithm
                 in an interactive environment, this article introduces
                 a novel error recovery mechanism. Our approach is
                 language independent, and relies on automatic
                 derivation of recovery rules from grammars. By taking
                 layout information into consideration it can
                 efficiently suggest natural recovery suggestions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ben-Amram:2012:TIL,
  author =       "Amir M. Ben-Amram and Samir Genaim and Abu Naser
                 Masud",
  title =        "On the Termination of Integer Loops",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "4",
  pages =        "16:1--16:24",
  month =        dec,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2400676.2400679",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 10 17:44:23 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article we study the decidability of
                 termination of several variants of simple integer
                 loops, without branching in the loop body and with
                 affine constraints as the loop guard (and possibly a
                 precondition). We show that termination of such loops
                 is undecidable in some cases, in particular, when the
                 body of the loop is expressed by a set of linear
                 inequalities where the coefficients are from $ Z \cup
                 \{ r \} $ with $r$ an arbitrary irrational; when the
                 loop is a sequence of instructions, that compute either
                 linear expressions or the step function; and when the
                 loop body is a piecewise linear deterministic update
                 with two pieces. The undecidability result is proven by
                 a reduction from counter programs, whose termination is
                 known to be undecidable. For the common case of integer
                 linear-constraint loops with rational coefficients we
                 have not succeeded in proving either decidability or
                 undecidability of termination, but we show that a Petri
                 net can be simulated with such a loop; this implies
                 some interesting lower bounds. For example, termination
                 for a partially specified input is at least
                 EXPSPACE-hard.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Feng:2012:BQP,
  author =       "Yuan Feng and Runyao Duan and Mingsheng Ying",
  title =        "Bisimulation for Quantum Processes",
  journal =      j-TOPLAS,
  volume =       "34",
  number =       "4",
  pages =        "17:1--17:43",
  month =        dec,
  year =         "2012",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2400676.2400680",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jan 10 17:44:23 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Quantum cryptographic systems have been commercially
                 available, with a striking advantage over classical
                 systems that their security and ability to detect the
                 presence of eavesdropping are provable based on the
                 principles of quantum mechanics. On the other hand,
                 quantum protocol designers may commit more faults than
                 classical protocol designers since human intuition is
                 poorly adapted to the quantum world. To offer formal
                 techniques for modeling and verification of quantum
                 protocols, several quantum extensions of process
                 algebra have been proposed. An important issue in
                 quantum process algebra is to discover a quantum
                 generalization of bisimulation preserved by various
                 process constructs, in particular, parallel
                 composition, where one of the major differences between
                 classical and quantum systems, namely quantum
                 entanglement, is present. Quite a few versions of
                 bisimulation have been defined for quantum processes in
                 the literature, but in the best case they are only
                 proved to be preserved by parallel composition of
                 purely quantum processes where no classical
                 communication is involved. Many quantum cryptographic
                 protocols, however, employ the LOCC (Local Operations
                 and Classical Communication) scheme, where classical
                 communication must be explicitly specified. So, a
                 notion of bisimulation preserved by parallel
                 composition in the circumstance of both classical and
                 quantum communication is crucial for process algebra
                 approach to verification of quantum cryptographic
                 protocols. In this article we introduce novel notions
                 of strong bisimulation and weak bisimulation for
                 quantum processes, and prove that they are congruent
                 with respect to various process algebra combinators
                 including parallel composition even when both classical
                 and quantum communication are present. We also
                 establish some basic algebraic laws for these
                 bisimulations. In particular, we show the uniqueness of
                 the solutions to recursive equations of quantum
                 processes, which proves useful in verifying complex
                 quantum protocols. To capture the idea that a quantum
                 process approximately implements its specification, and
                 provide techniques and tools for approximate reasoning,
                 a quantified version of strong bisimulation, which
                 defines for each pair of quantum processes a
                 bisimulation-based distance characterizing the extent
                 to which they are strongly bisimilar, is also
                 introduced.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Palsberg:2013:E,
  author =       "Jens Palsberg",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "1",
  pages =        "1:1--1:??",
  month =        apr,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2450136.2450141",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 30 18:56:06 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rossberg:2013:MMM,
  author =       "Andreas Rossberg and Derek Dreyer",
  title =        "Mixin' Up the {ML} Module System",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "1",
  pages =        "2:1--2:??",
  month =        apr,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2450136.2450137",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 30 18:56:06 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "ML modules provide hierarchical namespace management,
                 as well as fine-grained control over the propagation of
                 type information, but they do not allow modules to be
                 broken up into mutually recursive, separately
                 compilable components. Mixin modules facilitate
                 recursive linking of separately compiled components,
                 but they are not hierarchically composable and
                 typically do not support type abstraction. We
                 synthesize the complementary advantages of these two
                 mechanisms in a novel module system design we call
                 MixML. A MixML module is like an ML structure in which
                 some of the components are specified but not defined.
                 In other words, it unifies the ML structure and
                 signature languages into one. MixML seamlessly
                 integrates hierarchical composition, translucent
                 ML-style data abstraction, and mixin-style recursive
                 linking. Moreover, the design of MixML is clean and
                 minimalist; it emphasizes how all the salient,
                 semantically interesting features of the ML module
                 system (and several proposed extensions to it) can be
                 understood simply as stylized uses of a small set of
                 orthogonal underlying constructs, with mixin
                 composition playing a central role. We provide a
                 declarative type system for MixML, including two
                 important extensions: higher-order modules, and modules
                 as first-class values. We also present a sound and
                 complete, three-pass type-checking algorithm for this
                 system. The operational semantics of MixML is defined
                 by an elaboration translation into an internal core
                 language called LTG---namely, a polymorphic lambda
                 calculus with single-assignment references and
                 recursive type generativity---which employs a linear
                 type and kind system to track definedness of term and
                 type imports.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nandivada:2013:TFO,
  author =       "V. Krishna Nandivada and Jun Shirako and Jisheng Zhao
                 and Vivek Sarkar",
  title =        "A Transformation Framework for Optimizing
                 Task-Parallel Programs",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "1",
  pages =        "3:1--3:??",
  month =        apr,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2450136.2450138",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 30 18:56:06 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Task parallelism has increasingly become a trend with
                 programming models such as OpenMP 3.0, Cilk, Java
                 Concurrency, X10, Chapel and Habanero-Java (HJ) to
                 address the requirements of multicore programmers.
                 While task parallelism increases productivity by
                 allowing the programmer to express multiple levels of
                 parallelism, it can also lead to performance
                 degradation due to increased overheads. In this
                 article, we introduce a transformation framework for
                 optimizing task-parallel programs with a focus on task
                 creation and task termination operations. These
                 operations can appear explicitly in constructs such as
                 async, finish in X10 and HJ, task, taskwait in OpenMP
                 3.0, and spawn, sync in Cilk, or implicitly in
                 composite code statements such as foreach and ateach
                 loops in X10, forall and foreach loops in HJ, and
                 parallel loop in OpenMP. Our framework includes a
                 definition of data dependence in task-parallel
                 programs, a happens-before analysis algorithm, and a
                 range of program transformations for optimizing task
                 parallelism. Broadly, our transformations cover three
                 different but interrelated optimizations: (1)
                 finish-elimination, (2) forall-coarsening, and (3)
                 loop-chunking. Finish-elimination removes redundant
                 task termination operations, forall-coarsening replaces
                 expensive task creation and termination operations with
                 more efficient synchronization operations, and
                 loop-chunking extracts useful parallelism from ideal
                 parallelism. All three optimizations are specified in
                 an iterative transformation framework that applies a
                 sequence of relevant transformations until a fixed
                 point is reached. Further, we discuss the impact of
                 exception semantics on the specified transformations,
                 and extend them to handle task-parallel programs with
                 precise exception semantics. Experimental results were
                 obtained for a collection of task-parallel benchmarks
                 on three multicore platforms: a dual-socket 128-thread
                 (16-core) Niagara T2 system, a quad-socket 16-core
                 Intel Xeon SMP, and a quad-socket 32-core Power7 SMP.
                 We have observed that the proposed optimizations
                 interact with each other in a synergistic way, and
                 result in an overall geometric average performance
                 improvement between 6.28$ \times $ and 10.30$ \times $,
                 measured across all three platforms for the benchmarks
                 studied.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lim:2013:TSG,
  author =       "Junghee Lim and Thomas Reps",
  title =        "{TSL}: a System for Generating Abstract Interpreters
                 and its Application to Machine-Code Analysis",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "1",
  pages =        "4:1--4:??",
  month =        apr,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2450136.2450139",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 30 18:56:06 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article describes the design and implementation
                 of a system, called T SL (for Transformer Specification
                 Language), that provides a systematic solution to the
                 problem of creating retargetable tools for analyzing
                 machine code. TSL is a tool generator---that is, a
                 metatool---that automatically creates different
                 abstract interpreters for machine-code instruction
                 sets. The most challenging technical issue that we
                 faced in designing T SL was how to automate the
                 generation of the set of abstract transformers for a
                 given abstract interpretation of a given instruction
                 set. From a description of the concrete operational
                 semantics of an instruction set, together with the
                 datatypes and operations that define an abstract
                 domain, TSL automatically creates the set of abstract
                 transformers for the instructions of the instruction
                 set. TSL advances the state-of-the-art in program
                 analysis because it provides two dimensions of
                 parameterizability: (i) a given analysis component can
                 be retargeted to different instruction sets; (ii)
                 multiple analysis components can be created
                 automatically from a single specification of the
                 concrete operational semantics of the language to be
                 analyzed. T SL is an abstract-transformer-generator
                 generator. The article describes the principles behind
                 TSL, and discusses how one uses TSL to develop
                 different abstract interpreters.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Staiger-Stohr:2013:PIA,
  author =       "Stefan Staiger-St{\"o}hr",
  title =        "Practical Integrated Analysis of Pointers, Dataflow
                 and Control Flow",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "1",
  pages =        "5:1--5:??",
  month =        apr,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2450136.2450140",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 30 18:56:06 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article presents a family of static analyses to
                 determine pointer targets, control flow, and dataflow
                 in combination. The integrated solution to these
                 mutually dependent problems approaches the result from
                 the optimistic side. It is a general strategy for
                 static program analysis and does not need any upfront
                 approximation for one of the problems to overcome the
                 mutual dependencies. A degenerated case yields
                 Andersen's famous pointer analysis; otherwise, the
                 analyses are flow-sensitive and can support direct and
                 indirect strong updates, within the same cubic
                 asymptotic complexity as known for Andersen, albeit
                 with larger constants. Surprisingly, the ideas behind
                 the integrated analysis are intuitive. The strategy we
                 describe naturally evolves from considering the mutual
                 dependencies between the three problems, or from
                 generalizing Andersen's analysis to flow sensitivity.
                 Such a flow-sensitive Andersen analysis not only
                 computes pointer targets with higher precision than the
                 original analysis, but it also creates an
                 interprocedural SSA form at the same time. Our
                 extensive experimental evaluation shows that the
                 integrated solution is practical as it can be applied
                 to reasonably large real-world programs within a few
                 seconds or minutes. This uses some optimizations which
                 together achieve a speedup of more than 100 for several
                 programs. We compare several members of the family of
                 analyses, from flow- and field-insensitive to flow- and
                 field-sensitive with strong updates, both with and
                 without optimizations. This gives some insights into
                 the effects of these dimensions of precision on the
                 results. It also sheds new light on the benefits of
                 flow sensitivity versus the costs associated with it.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nanevski:2013:DTT,
  author =       "Aleksandar Nanevski and Anindya Banerjee and Deepak
                 Garg",
  title =        "Dependent Type Theory for Verification of Information
                 Flow and Access Control Policies",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "2",
  pages =        "6:1--6:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2491522.2491523",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 29 16:11:39 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Dedicated to the memory of John C. Reynolds
                 (1935--2013). We present Relational Hoare Type Theory
                 (RHTT), a novel language and verification system
                 capable of expressing and verifying rich information
                 flow and access control policies via dependent types.
                 We show that a number of security policies which have
                 been formalized separately in the literature can all be
                 expressed in RHTT using only standard type-theoretic
                 constructions such as monads, higher-order functions,
                 abstract types, abstract predicates, and modules.
                 Example security policies include conditional
                 declassification, information erasure, and
                 state-dependent information flow and access control.
                 RHTT can reason about such policies in the presence of
                 dynamic memory allocation, deallocation, pointer
                 aliasing and arithmetic.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Binkley:2013:EIL,
  author =       "David Binkley and Nicolas Gold and Mark Harman and
                 Syed Islam and Jens Krinke and Zheng Li",
  title =        "Efficient Identification of Linchpin Vertices in
                 Dependence Clusters",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2491522.2491524",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 29 16:11:39 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Several authors have found evidence of large
                 dependence clusters in the source code of a diverse
                 range of systems, domains, and programming languages.
                 This raises the question of how we might efficiently
                 locate the fragments of code that give rise to large
                 dependence clusters. We introduce an algorithm for the
                 identification of linchpin vertices, which hold
                 together large dependence clusters, and prove
                 correctness properties for the algorithm's primary
                 innovations. We also report the results of an empirical
                 study concerning the reduction in analysis time that
                 our algorithm yields over its predecessor using a
                 collection of 38 programs containing almost half a
                 million lines of code. Our empirical findings indicate
                 improvements of almost two orders of magnitude, making
                 it possible to process larger programs for which it
                 would have previously been impractical.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Botincan:2013:PDP,
  author =       "Matko Botincan and Mike Dodds and Suresh Jagannathan",
  title =        "Proof-Directed Parallelization Synthesis by Separation
                 Logic",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jul,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2491522.2491525",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 29 16:11:39 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present an analysis which takes as its input a
                 sequential program, augmented with annotations
                 indicating potential parallelization opportunities, and
                 a sequential proof, written in separation logic, and
                 produces a correctly synchronized parallelized program
                 and proof of that program. Unlike previous work, ours
                 is not a simple independence analysis that admits
                 parallelization only when threads do not interfere;
                 rather, we insert synchronization to preserve
                 dependencies in the sequential program that might be
                 violated by a na{\"\i}ve translation. Separation logic
                 allows us to parallelize fine-grained patterns of
                 resource usage, moving beyond straightforward points-to
                 analysis. The sequential proof need only represent
                 shape properties, meaning we can handle complex
                 algorithms without verifying every aspect of their
                 behavior. Our analysis works by using the sequential
                 proof to discover dependencies between different parts
                 of the program. It leverages these discovered
                 dependencies to guide the insertion of synchronization
                 primitives into the parallelized program, and to ensure
                 that the resulting parallelized program satisfies the
                 same specification as the original sequential program,
                 and exhibits the same sequential behavior. Our analysis
                 is built using frame inference and abduction, two
                 techniques supported by an increasing number of
                 separation logic tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barthe:2013:PRR,
  author =       "Gilles Barthe and Boris K{\"o}pf and Federico Olmedo
                 and Santiago Zanella-B{\'e}guelin",
  title =        "Probabilistic Relational Reasoning for Differential
                 Privacy",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "3",
  pages =        "9:1--9:49",
  month =        nov,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2492061",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 8 17:09:04 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Differential privacy is a notion of confidentiality
                 that allows useful computations on sensible data while
                 protecting the privacy of individuals. Proving
                 differential privacy is a difficult and error-prone
                 task that calls for principled approaches and tool
                 support. Approaches based on linear types and static
                 analysis have recently emerged; however, an increasing
                 number of programs achieve privacy using techniques
                 that fall out of their scope. Examples include programs
                 that aim for weaker, approximate differential privacy
                 guarantees and programs that achieve differential
                 privacy without using any standard mechanisms.
                 Providing support for reasoning about the privacy of
                 such programs has been an open problem. We report on
                 CertiPriv, a machine-checked framework for reasoning
                 about differential privacy built on top of the Coq
                 proof assistant. The central component of CertiPriv is
                 a quantitative extension of probabilistic relational
                 Hoare logic that enables one to derive differential
                 privacy guarantees for programs from first principles.
                 We demonstrate the applicability of CertiPriv on a
                 number of examples whose formal analysis is out of the
                 reach of previous techniques. In particular, we provide
                 the first machine-checked proofs of correctness of the
                 Laplacian, Gaussian, and exponential mechanisms and of
                 the privacy of randomized and streaming algorithms from
                 the literature.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bouajjani:2013:ARP,
  author =       "Ahmed Bouajjani and Michael Emmi",
  title =        "Analysis of Recursively Parallel Programs",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "3",
  pages =        "10:1--10:49",
  month =        nov,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2518188",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 8 17:09:04 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose a general formal model of isolated
                 hierarchical parallel computations, and identify
                 several fragments to match the concurrency constructs
                 present in real-world programming languages such as
                 Cilk and X10. By associating fundamental formal models
                 (vector addition systems with recursive transitions) to
                 each fragment, we provide a common platform for
                 exposing the relative difficulties of algorithmic
                 reasoning. For each case we measure the complexity of
                 deciding state reachability for finite-data recursive
                 programs, and propose algorithms for the decidable
                 cases. The complexities which include PTIME, NP,
                 EXPSPACE, and 2EXPTIME contrast with undecidable state
                 reachability for recursive multithreaded programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Strickland:2013:CFC,
  author =       "T. Stephen Strickland and Christos Dimoulas and Asumu
                 Takikawa and Matthias Felleisen",
  title =        "Contracts for First-Class Classes",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "3",
  pages =        "11:1--11:58",
  month =        nov,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2518189",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Nov 8 17:09:04 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "First-class classes enable programmers to abstract
                 over patterns in the class hierarchy and to experiment
                 with new forms of object-oriented programming such as
                 mixins and traits. This increase in expressive power
                 calls for tools to control the complexity of the
                 software architecture. A contract system is one
                 possible tool that has seen much use in object-oriented
                 programming languages, but existing contract systems
                 cannot cope with first-class classes. On the one hand,
                 the typical contract language deals only with plain
                 values such as numbers, while classes are higher-order
                 values. On the other hand, contract specifications are
                 usually contained within class definitions, while
                 classes as values call for a separate contract
                 language. This article presents the design and
                 implementation of a contract system for first-class
                 classes as well as a two-pronged evaluation. The first
                 one states and proves a ``blame correctness'' theorem
                 for a model of our language. The theorem shows that
                 when the contract system assigns blame to a component
                 for a contract violation, the component is indeed
                 responsible for providing the nonconforming value. The
                 second part, consisting of benchmarks and case studies,
                 demonstrates the need for the rich contract language
                 and validates that our implementation approach is
                 performant with respect to time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lochbihler:2013:MJM,
  author =       "Andreas Lochbihler",
  title =        "Making the {Java} memory model safe",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "4",
  pages =        "12:1--12:??",
  month =        dec,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2518191",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 31 14:22:03 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This work presents a machine-checked formalisation of
                 the Java memory model and connects it to an operational
                 semantics for Java and Java bytecode. For the whole
                 model, I prove the data race freedom guarantee and type
                 safety. The model extends previous formalisations by
                 dynamic memory allocation, thread spawns and joins,
                 infinite executions, the wait-notify mechanism, and
                 thread interruption, all of which interact in subtle
                 ways with the memory model. The formalisation resulted
                 in numerous clarifications of and fixes to the existing
                 JMM specification.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sampaio:2013:DA,
  author =       "Diogo Sampaio and Rafael Martins de Souza and Sylvain
                 Collange and Fernando Magno Quint{\~a}o Pereira",
  title =        "Divergence analysis",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "4",
  pages =        "13:1--13:??",
  month =        dec,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2523815",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 31 14:22:03 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Growing interest in graphics processing units has
                 brought renewed attention to the Single Instruction
                 Multiple Data (SIMD) execution model. SIMD machines
                 give application developers tremendous computational
                 power; however, programming them is still challenging.
                 In particular, developers must deal with memory and
                 control-flow divergences. These phenomena stem from a
                 condition that we call data divergence, which occurs
                 whenever two processing elements (PEs) see the same
                 variable name holding different values. This article
                 introduces divergence analysis, a static analysis that
                 discovers data divergences. This analysis, currently
                 deployed in an industrial quality compiler, is useful
                 in several ways: it improves the translation of SIMD
                 code to non-SIMD CPUs, it helps developers to manually
                 improve their SIMD applications, and it also guides the
                 automatic optimization of SIMD programs. We demonstrate
                 this last point by introducing the notion of a
                 divergence-aware register spiller. This spiller uses
                 information from our analysis to either rematerialize
                 or share common data between PEs. As a testimony of its
                 effectiveness, we have tested it on a suite of 395 CUDA
                 kernels from well-known benchmarks. The
                 divergence-aware spiller produces GPU code that is
                 26.21\% faster than the code produced by the register
                 allocator used in the baseline compiler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nikolic:2013:RAP,
  author =       "Durica Nikoli{\'c} and Fausto Spoto",
  title =        "Reachability analysis of program variables",
  journal =      j-TOPLAS,
  volume =       "35",
  number =       "4",
  pages =        "14:1--14:??",
  month =        dec,
  year =         "2013",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2529990",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Dec 31 14:22:03 MST 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Reachability from a program variable $v$ to a program
                 variable $w$ states that from $v$, it is possible to
                 follow a path of memory locations that leads to the
                 object bound to $w$. We present a new abstract domain
                 for the static analysis of possible reachability
                 between program variables or, equivalently, definite
                 unreachability between them. This information is
                 important for improving the precision of other static
                 analyses, such as side-effects, field initialization,
                 cyclicity and path-length analysis, as well as more
                 complex analyses built upon them, such as nullness and
                 termination analysis. We define and prove correct our
                 reachability analysis for Java bytecode, defined as a
                 constraint-based analysis, where the constraint is a
                 graph whose nodes are the program points and whose arcs
                 propagate reachability information in accordance to the
                 abstract semantics of each bytecode instruction. For
                 each program point $p$, our reachability analysis
                 produces an overapproximation of the ordered pairs of
                 variables $ \langle v, w \rangle $ such that $v$ might
                 reach $w$ at $p$. Seen the other way around, if a pair
                 $ \langle v, w \rangle $ is not present in the
                 overapproximation at $p$, then $v$ definitely does not
                 reach $w$ at $p$. We have implemented the analysis
                 inside the Julia static analyzer. Our experiments of
                 analysis of nontrivial Java and Android programs show
                 the improvement of precision due to the presence of
                 reachability information. Moreover, reachability
                 analysis actually reduces the overall cost of nullness
                 and termination analysis.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chen:2014:ETI,
  author =       "Sheng Chen and Martin Erwig and Eric Walkingshaw",
  title =        "Extending Type Inference to Variational Programs",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "1",
  pages =        "1:1--1:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2518190",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 21 14:54:50 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Through the use of conditional compilation and related
                 tools, many software projects can be used to generate a
                 huge number of related programs. The problem of typing
                 such variational software is difficult. The brute-force
                 strategy of generating all variants and typing each one
                 individually is: (1) usually infeasible for efficiency
                 reasons and (2) produces results that do not map well
                 to the underlying variational program. Recent research
                 has focused mainly on efficiency and addressed only the
                 problem of type checking. In this work we tackle the
                 more general problem of variational type inference and
                 introduce variational types to represent the result of
                 typing a variational program. We introduce the
                 variational lambda calculus (VLC) as a formal
                 foundation for research on typing variational programs.
                 We define a type system for VLC in which VLC
                 expressions are mapped to correspondingly variational
                 types. We show that the type system is correct by
                 proving that the typing of expressions is preserved
                 over the process of variation elimination, which
                 eventually results in a plain lambda calculus
                 expression and its corresponding type. We identify a
                 set of equivalence rules for variational types and
                 prove that the type unification problem modulo these
                 equivalence rules is unitary and decidable; we also
                 present a sound and complete unification algorithm.
                 Based on the unification algorithm, the variational
                 type inference algorithm is an extension of algorithm
                 W. We show that it is sound and complete and computes
                 principal types. We also consider the extension of VLC
                 with sum types, a necessary feature for supporting
                 variational data types, and demonstrate that the
                 previous theoretical results also hold under this
                 extension. Finally, we characterize the complexity of
                 variational type inference and demonstrate the
                 efficiency gains over the brute-force strategy.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Stork:2014:APB,
  author =       "Sven Stork and Karl Naden and Joshua Sunshine and
                 Manuel Mohr and Alcides Fonseca and Paulo Marques and
                 Jonathan Aldrich",
  title =        "{{\AE}minium}: a Permission-Based
                 Concurrent-by-Default Programming Language Approach",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "1",
  pages =        "2:1--2:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2543920",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 21 14:54:50 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Writing concurrent applications is extremely
                 challenging, not only in terms of producing bug-free
                 and maintainable software, but also for enabling
                 developer productivity. In this article we present the
                 {\AE}minium concurrent-by-default programming language.
                 Using {\AE}minium programmers express data dependencies
                 rather than control flow between instructions.
                 Dependencies are expressed using permissions, which are
                 used by the type system to automatically parallelize
                 the application. The {\AE}minium approach provides a
                 modular and composable mechanism for writing concurrent
                 applications, preventing data races in a provable way.
                 This allows programmers to shift their attention from
                 low-level, error-prone reasoning about thread
                 interleaving and synchronization to focus on the core
                 functionality of their applications. We study the
                 semantics of {\AE}minium through $ \mu $ {\AE}minium, a
                 sound core calculus that leverages permission flow to
                 enable concurrent-by-default execution. After
                 discussing our prototype implementation we present
                 several case studies of our system. Our case studies
                 show up to 6.5X speedup on an eight-core machine when
                 leveraging data group permissions to manage access to
                 shared state, and more than 70\% higher throughput in a
                 Web server application.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liang:2014:RGB,
  author =       "Hongjin Liang and Xinyu Feng and Ming Fu",
  title =        "Rely-Guarantee-Based Simulation for Compositional
                 Verification of Concurrent Program Transformations",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "1",
  pages =        "3:1--3:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2576235",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 21 14:54:50 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Verifying program transformations usually requires
                 proving that the resulting program (the target) refines
                 or is equivalent to the original one (the source).
                 However, the refinement relation between individual
                 sequential threads cannot be preserved in general with
                 the presence of parallel compositions, due to
                 instruction reordering and the different granularities
                 of atomic operations at the source and the target. On
                 the other hand, the refinement relation defined based
                 on fully abstract semantics of concurrent programs
                 assumes arbitrary parallel environments, which is too
                 strong and cannot be satisfied by many well-known
                 transformations. In this article, we propose a
                 {Rely}-{Guarantee}-based {Simulation} (RGSim) to verify
                 concurrent program transformations. The relation is
                 parametrized with constraints of the environments that
                 the source and the target programs may compose with. It
                 considers the interference between threads and their
                 environments, thus is less permissive than relations
                 over sequential programs. It is compositional with
                 respect to parallel compositions as long as the
                 constraints are satisfied. Also, RGSim does not require
                 semantics preservation under all environments, and can
                 incorporate the assumptions about environments made by
                 specific program transformations in the form of
                 rely/guarantee conditions. We use RGSim to reason about
                 optimizations and prove atomicity of concurrent
                 objects. We also propose a general garbage collector
                 verification framework based on RGSim, and verify the
                 Boehm et al. concurrent mark-sweep GC.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Barthe:2014:FVS,
  author =       "Gilles Barthe and Delphine Demange and David
                 Pichardie",
  title =        "Formal Verification of an {SSA-Based} Middle-End for
                 {CompCert}",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "1",
  pages =        "4:1--4:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2579080",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Mar 21 14:54:50 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "CompCert is a formally verified compiler that
                 generates compact and efficient code for a large subset
                 of the C language. However, CompCert foregoes using
                 SSA, an intermediate representation employed by many
                 compilers that enables writing simpler, faster
                 optimizers. In fact, it has remained an open problem to
                 verify formally an SSA-based compiler. We report on a
                 formally verified, SSA-based middle-end for CompCert.
                 In addition to providing a formally verified SSA-based
                 middle-end, we address two problems raised by Leroy in
                 [2009]: giving an intuitive formal semantics to SSA,
                 and leveraging its global properties to reason locally
                 about program optimizations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Aung:2014:SS,
  author =       "Min Aung and Susan Horwitz and Rich Joiner and Thomas
                 Reps",
  title =        "Specialization Slicing",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "2",
  pages =        "5:1--5:??",
  month =        jul,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2566620",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 9 08:13:32 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This paper defines a new variant of program slicing,
                 called specialization slicing, and presents an
                 algorithm for the specialization-slicing problem that
                 creates an optimal output slice. An algorithm for
                 specialization slicing is polyvariant: for a given
                 procedure $p$, the algorithm may create multiple
                 specialized copies of $p$. In creating specialized
                 procedures, the algorithm must decide for which
                 patterns of formal parameters a given procedure should
                 be specialized and which program elements should be
                 included in each specialized procedure. We formalize
                 the specialization-slicing problem as a partitioning
                 problem on the elements of the possibly infinite
                 unrolled program. To manipulate possibly infinite sets
                 of program elements, the algorithm makes use of
                 automata-theoretic techniques originally developed in
                 the model-checking community. The algorithm returns a
                 finite answer that is optimal (with respect to a
                 criterion defined in the article). In particular, (i)
                 each element replicated by the specialization-slicing
                 algorithm provides information about specialized
                 patterns of program behavior that are intrinsic to the
                 program, and (ii) the answer is of minimal size (i.e.,
                 among all possible answers with property (i), there is
                 no smaller one). The specialization-slicing algorithm
                 provides a new way to create executable slices.
                 Moreover, by combining specialization slicing with
                 forward slicing, we obtain a method for removing
                 unwanted features from a program. While it was
                 previously known how to solve the feature-removal
                 problem for single-procedure programs, it was not known
                 how to solve it for programs with procedure calls.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jagannathan:2014:ARV,
  author =       "Suresh Jagannathan and Vincent Laporte and Gustavo
                 Petri and David Pichardie and Jan Vitek",
  title =        "Atomicity Refinement for Verified Compilation",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "2",
  pages =        "6:1--6:??",
  month =        jul,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2601339",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 9 08:13:32 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We consider the verified compilation of high-level
                 managed languages like Java or C\# whose intermediate
                 representations provide support for shared-memory
                 synchronization and automatic memory management. Our
                 development is framed in the context of the Total Store
                 Order relaxed memory model. Ensuring compiler
                 correctness is challenging because high-level actions
                 are translated into sequences of nonatomic actions with
                 compiler-injected snippets of racy code; the behavior
                 of this code depends not only on the actions of other
                 threads but also on out-of-order executions performed
                 by the processor. A na{\"\i}ve proof of correctness
                 would require reasoning over all possible thread
                 interleavings. In this article, we propose a
                 refinement-based proof methodology that precisely
                 relates concurrent code expressed at different
                 abstraction levels, cognizant throughout of the relaxed
                 memory semantics of the underlying processor. Our
                 technique allows the compiler writer to reason
                 compositionally about the atomicity of low-level
                 concurrent code used to implement managed services. We
                 illustrate our approach with examples taken from the
                 verification of a concurrent garbage collector.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alglave:2014:HCM,
  author =       "Jade Alglave and Luc Maranget and Michael Tautschnig",
  title =        "Herding Cats: Modelling, Simulation, Testing, and Data
                 Mining for Weak Memory",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jul,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2627752",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Aug 9 08:13:32 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose an axiomatic generic framework for
                 modelling weak memory. We show how to instantiate this
                 framework for Sequential Consistency (SC), Total Store
                 Order (TSO), C++ restricted to release-acquire atomics,
                 and Power. For Power, we compare our model to a
                 preceding operational model in which we found a flaw.
                 To do so, we define an operational model that we show
                 equivalent to our axiomatic model. We also propose a
                 model for ARM. Our testing on this architecture
                 revealed a behaviour later acknowledged as a bug by
                 ARM, and more recently, 31 additional anomalies. We
                 offer a new simulation tool, called herd, which allows
                 the user to specify the model of his choice in a
                 concise way. Given a specification of a model, the tool
                 becomes a simulator for that model. The tool relies on
                 an axiomatic description; this choice allows us to
                 outperform all previous simulation tools. Additionally,
                 we confirm that verification time is vastly improved,
                 in the case of bounded model checking. Finally, we put
                 our models in perspective, in the light of empirical
                 data obtained by analysing the C and C++ code of a
                 Debian Linux distribution. We present our new analysis
                 tool, called mole, which explores a piece of code to
                 find the weak memory idioms that it uses.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Oh:2014:GSA,
  author =       "Hakjoo Oh and Kihong Heo and Wonchan Lee and Woosuk
                 Lee and Daejun Park and Jeehoon Kang and Kwangkeun Yi",
  title =        "Global Sparse Analysis Framework",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "3",
  pages =        "8:1--8:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2590811",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:06:29 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article, we present a general method for
                 achieving global static analyzers that are precise and
                 sound, yet also scalable. Our method, on top of the
                 abstract interpretation framework, is a general sparse
                 analysis technique that supports relational as well as
                 nonrelational semantics properties for various
                 programming languages. Analysis designers first use the
                 abstract interpretation framework to have a global and
                 correct static analyzer whose scalability is
                 unattended. Upon this underlying sound static analyzer,
                 analysis designers add our generalized sparse analysis
                 techniques to improve its scalability while preserving
                 the precision of the underlying analysis. Our method
                 prescribes what to prove to guarantee that the
                 resulting sparse version should preserve the precision
                 of the underlying analyzer. We formally present our
                 framework and show that existing sparse analyses are
                 all restricted instances of our framework. In addition,
                 we show more semantically elaborate design examples of
                 sparse nonrelational and relational static analyses. We
                 then present their implementation results that scale to
                 globally analyze up to one million lines of C programs.
                 We also show a set of implementation techniques that
                 turn out to be critical to economically support the
                 sparse analysis process.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Esparza:2014:PBV,
  author =       "Javier Esparza and Pierre Ganty and Tom{\'a}s Poch",
  title =        "Pattern-Based Verification for Multithreaded
                 Programs",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "3",
  pages =        "9:1--9:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2629644",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:06:29 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Pattern-based verification checks the correctness of
                 program executions that follow a given pattern, a
                 regular expression over the alphabet of program
                 transitions of the form $ w_1^*, \ldots {},_n^* $ w.
                 For multithreaded programs, the alphabet of the pattern
                 is given by the reads and writes to the shared storage.
                 We study the complexity of pattern-based verification
                 for multithreaded programs with shared counters and
                 finite variables. While unrestricted verification is
                 undecidable for abstracted multithreaded programs with
                 recursive procedures and PSPACE-complete for abstracted
                 multithreaded while-programs (even without counters),
                 we show that pattern-based verification is NP-complete
                 for both classes, even in the presence of counters. We
                 then conduct a multiparameter analysis to study the
                 complexity of the problem on its three natural
                 parameters (number of threads+counters+variables,
                 maximal size of a thread, size of the pattern) and on
                 two parameters related to thread structure (maximal
                 number of procedures per thread and longest simple path
                 of procedure calls). We present an algorithm that for a
                 fixed number of threads, counters, variables, and
                 pattern size solves the verification problem in $ {\rm
                 st}^{O ({\rm lsp} + \lceil log ({\rm pr} + 1) \rceil)}
                 $ time, where $ {\rm st} $ is the maximal size of a
                 thread, $ {\rm pr} $ is the maximal number of
                 procedures per thread, and $ {\rm lsp} $ is the longest
                 simple path of procedure calls.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Tzannes:2014:LSR,
  author =       "Alexandros Tzannes and George C. Caragea and Uzi
                 Vishkin and Rajeev Barua",
  title =        "Lazy Scheduling: a Runtime Adaptive Scheduler for
                 Declarative Parallelism",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "3",
  pages =        "10:1--10:??",
  month =        sep,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2629643",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:06:29 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Lazy scheduling is a runtime scheduler for
                 task-parallel codes that effectively coarsens
                 parallelism on load conditions in order to
                 significantly reduce its overheads compared to existing
                 approaches, thus enabling the efficient execution of
                 more fine-grained tasks. Unlike other adaptive dynamic
                 schedulers, lazy scheduling does not maintain any
                 additional state to infer system load and does not make
                 irrevocable serialization decisions. These two features
                 allow it to scale well and to provide excellent load
                 balancing in practice but at a much lower overhead cost
                 compared to work stealing, the golden standard of
                 dynamic schedulers. We evaluate three variants of lazy
                 scheduling on a set of benchmarks on three different
                 platforms and find it to substantially outperform
                 popular work stealing implementations on fine-grained
                 codes. Furthermore, we show that the vast performance
                 gap between manually coarsened and fully parallel code
                 is greatly reduced by lazy scheduling, and that, with
                 minimal static coarsening, lazy scheduling delivers
                 performance very close to that of fully tuned code. The
                 tedious manual coarsening required by the best existing
                 work stealing schedulers and its damaging effect on
                 performance portability have kept novice and
                 general-purpose programmers from parallelizing their
                 codes. Lazy scheduling offers the foundation for a
                 declarative parallel programming methodology that
                 should attract those programmers by minimizing the need
                 for manual coarsening and by greatly enhancing the
                 performance portability of parallel code.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Elder:2014:ADA,
  author =       "Matt Elder and Junghee Lim and Tushar Sharma and Tycho
                 Andersen and Thomas Reps",
  title =        "Abstract Domains of Affine Relations",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "4",
  pages =        "11:1--11:??",
  month =        oct,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2651361",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:05:40 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article considers some known abstract domains for
                 affine-relation analysis (ARA), along with several
                 variants, and studies how they relate to each other.
                 The various domains represent sets of points that
                 satisfy affine relations over variables that hold
                 machine integers and are based on an extension of
                 linear algebra to modules over a ring (in particular,
                 arithmetic performed modulo $ 2^w $, for some
                 machine-integer width w ). We show that the abstract
                 domains of M{\"u}ller--Olm\slash Seidl (MOS) and
                 King\slash S{\o}ndergaard (KS) are, in general,
                 incomparable. However, we give sound interconversion
                 methods. In other words, we give an algorithm to
                 convert a KS element $ v_{\rm KS} $ to an
                 overapproximating MOS element $ v_{\rm MOS} $ --- that
                 is, $ \gamma (v_{\rm KS}) \subseteq \gamma (v_{\rm
                 MOS}) $ --- as well as an algorithm to convert an MOS
                 element $ w_{\rm MOS} $ to an overapproximating KS
                 element $ w_{KS} $ --- that is, $ \gamma (w_{\rm MOS})
                 \subseteq \gamma (w_{KS}) $. The article provides
                 insight on the range of options that one has for
                 performing ARA in a program analyzer: --- We describe
                 how to perform a greedy, operator-by-operator
                 abstraction method to obtain KS abstract transformers.
                 --- We also describe a more global approach to
                 obtaining KS abstract transformers that considers the
                 semantics of an entire instruction, basic block, or
                 other loop-free program fragment. The latter method can
                 yield best abstract transformers, and hence can be more
                 precise than the former method. However, the latter
                 method is more expensive. We also explain how to use
                 the KS domain for interprocedural program analysis
                 using a bit-precise concrete semantics, but without bit
                 blasting.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Garcia:2014:FTO,
  author =       "Ronald Garcia and {\'E}ric Tanter and Roger Wolff and
                 Jonathan Aldrich",
  title =        "Foundations of Typestate-Oriented Programming",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "4",
  pages =        "12:1--12:??",
  month =        oct,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2629609",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:05:40 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Typestate reflects how the legal operations on
                 imperative objects can change at runtime as their
                 internal state changes. A typestate checker can
                 statically ensure, for instance, that an object method
                 is only called when the object is in a state for which
                 the operation is well defined. Prior work has shown how
                 modular typestate checking can be achieved thanks to
                 access permissions and state guarantees. However,
                 typestate was not treated as a primitive language
                 concept: typestate checkers are an additional
                 verification layer on top of an existing language. In
                 contrast, a typestate-oriented programming (TSOP)
                 language directly supports expressing typestates. For
                 example, in the Plaid programming language, the
                 typestate of an object directly corresponds to its
                 class, and that class can change dynamically. Plaid
                 objects have not only typestate-dependent interfaces
                 but also typestate-dependent behaviors and runtime
                 representations. This article lays foundations for TSOP
                 by formalizing a nominal object-oriented language with
                 mutable state that integrates typestate change and
                 typestate checking as primitive concepts. We first
                 describe a statically typed language-Featherweight
                 Typestate (FT)-where the types of object references are
                 augmented with access permissions and state guarantees.
                 We describe a novel flow-sensitive permission-based
                 type system for FT. Because static typestate checking
                 is still too rigid for some applications, we then
                 extend this language into a gradually typed
                 language-Gradual Featherweight Typestate (GFT). This
                 language extends the notion of gradual typing to
                 account for typestate: gradual typestate checking
                 seamlessly combines static and dynamic checking by
                 automatically inserting runtime checks into programs.
                 The gradual type system of GFT allows programmers to
                 write dynamically safe code even when the static type
                 checker can only partly verify it.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hayden:2014:KEG,
  author =       "Christopher M. Hayden and Karla Saur and Edward K.
                 Smith and Michael Hicks and Jeffrey S. Foster",
  title =        "{Kitsune}: Efficient, General-Purpose Dynamic Software
                 Updating for {C}",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "4",
  pages =        "13:1--13:??",
  month =        oct,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2629460",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:05:40 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Dynamic software updating (DSU) systems facilitate
                 software updates to running programs, thereby
                 permitting developers to add features and fix bugs
                 without downtime. This article introduces Kitsune, a
                 DSU system for C. Kitsune's design has three notable
                 features. First, Kitsune updates the whole program,
                 rather than individual functions, using a mechanism
                 that places no restrictions on data representations or
                 allowed compiler optimizations. Second, Kitsune makes
                 the important aspects of updating explicit in the
                 program text, making the program's semantics easy to
                 understand while minimizing programmer effort. Finally,
                 the programmer can write simple specifications to
                 direct Kitsune to generate code that traverses and
                 transforms old-version state for use by new code; such
                 state transformation is often necessary and is
                 significantly more difficult in prior DSU systems. We
                 have used Kitsune to update six popular, open-source,
                 single- and multithreaded programs and find that few
                 program changes are required to use Kitsune, that it
                 incurs essentially no performance overhead, and that
                 update times are fast.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kaiser:2014:WAM,
  author =       "Alexander Kaiser and Daniel Kroening and Thomas Wahl",
  title =        "A Widening Approach to Multithreaded Program
                 Verification",
  journal =      j-TOPLAS,
  volume =       "36",
  number =       "4",
  pages =        "14:1--14:??",
  month =        oct,
  year =         "2014",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2629608",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 28 17:05:40 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Pthread-style multithreaded programs feature rich
                 thread communication mechanisms, such as shared
                 variables, signals, and broadcasts. In this article, we
                 consider the automated verification of such programs
                 where an unknown number of threads execute a given
                 finite-data procedure in parallel. Such procedures are
                 typically obtained as predicate abstractions of
                 recursion-free source code written in C or Java. Many
                 safety problems over finite-data replicated
                 multithreaded programs are decidable via a reduction to
                 the coverability problem in certain types of
                 well-ordered infinite-state transition systems. On the
                 other hand, in full generality, this problem is
                 Ackermann-hard, which seems to rule out efficient
                 algorithmic treatment. We present a novel, sound, and
                 complete yet empirically efficient solution. Our
                 approach is to judiciously widen the original set of
                 coverability targets by configurations that involve
                 fewer threads and are thus easier to decide, and whose
                 exploration may well be sufficient: if they turn out
                 uncoverable, so are the original targets. To soften the
                 impact of ``bad guesses'' --- configurations that turn
                 out coverable --- the exploration is accompanied by a
                 parallel engine that generates coverable
                 configurations; none of these is ever selected for
                 widening. Its job being merely to prevent bad widening
                 choices, such an engine need not be complete for
                 coverability analysis, which enables a range of
                 existing partial (e.g., nonterminating) techniques. We
                 present extensive experiments on multithreaded C
                 programs, including device driver code from FreeBSD,
                 Solaris, and Linux distributions. Our approach
                 outperforms existing coverability methods by orders of
                 magnitude.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gange:2015:IAM,
  author =       "Graeme Gange and Jorge A. Navas and Peter Schachte and
                 Harald S{\o}ndergaard and Peter J. Stuckey",
  title =        "Interval Analysis and Machine Arithmetic: Why
                 Signedness Ignorance Is Bliss",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2651360",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 21 07:13:17 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The most commonly used integer types have fixed
                 bit-width, making it possible for computations to
                 ``wrap around,'' and many programs depend on this
                 behaviour. Yet much work to date on program analysis
                 and verification of integer computations treats
                 integers as having infinite precision, and most
                 analyses that do respect fixed width lose precision
                 when overflow is possible. We present a novel integer
                 interval abstract domain that correctly handles
                 wrap-around. The analysis is signedness agnostic. By
                 treating integers as strings of bits, only considering
                 signedness for operations that treat them differently,
                 we produce precise, correct results at a modest cost in
                 execution time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Palsberg:2015:E,
  author =       "Jens Palsberg",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2683389",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 21 07:13:17 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1e",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Nowatzki:2015:SFS,
  author =       "Tony Nowatzki and Michael Sartin-Tarm and Lorenzo {De
                 Carli} and Karthikeyan Sankaralingam and Cristian Estan
                 and Behnam Robatmili",
  title =        "A Scheduling Framework for Spatial Architectures
                 Across Multiple Constraint-Solving Theories",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jan,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2658993",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 21 07:13:17 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Spatial architectures provide energy-efficient
                 computation but require effective scheduling
                 algorithms. Existing heuristic-based approaches offer
                 low compiler/architect productivity, little optimality
                 insight, and low architectural portability. We seek to
                 develop a spatial-scheduling framework by utilizing
                 constraint-solving theories and find that architecture
                 primitives and scheduler responsibilities can be
                 related through five abstractions: computation
                 placement, data routing, event timing, resource
                 utilization, and the optimization objective. We encode
                 these responsibilities as 20 mathematical constraints,
                 using SMT and ILP, and create schedulers for the TRIPS,
                 DySER, and PLUG architectures. Our results show that a
                 general declarative approach using constraint solving
                 is implementable, is practical, and can outperform
                 specialized schedulers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Demetrescu:2015:RIP,
  author =       "Camil Demetrescu and Irene Finocchi and Andrea
                 Ribichini",
  title =        "Reactive Imperative Programming with Dataflow
                 Constraints",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jan,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2623200",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 21 07:13:17 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Dataflow languages provide natural support for
                 specifying constraints between objects in dynamic
                 applications, where programs need to react efficiently
                 to changes in their environment. In this article, we
                 show that one-way dataflow constraints, largely
                 explored in the context of interactive applications,
                 can be seamlessly integrated in any imperative language
                 and can be used as a general paradigm for writing
                 performance-critical reactive applications that require
                 efficient incremental computations. In our framework,
                 programmers can define ordinary statements of the
                 imperative host language that enforce constraints
                 between objects stored in special memory locations
                 designated as ``reactive.'' Reactive objects can be of
                 any legal type in the host language, including
                 primitive data types, pointers, arrays, and structures.
                 Statements defining constraints are automatically
                 re-executed every time their input memory locations
                 change, letting a program behave like a spreadsheet
                 where the values of some variables depend on the values
                 of other variables. The constraint-solving mechanism is
                 handled transparently by altering the semantics of
                 elementary operations of the host language for reading
                 and modifying objects. We provide a formal semantics
                 and describe a concrete embodiment of our technique
                 into C/C++, showing how to implement it efficiently in
                 conventional platforms using off-the-shelf compilers.
                 We discuss common coding idioms and relevant
                 applications to reactive scenarios, including
                 incremental computation, observer design pattern, data
                 structure repair, and software visualization. The
                 performance of our implementation is compared to
                 problem-specific change propagation algorithms, as well
                 as to language-centric approaches such as
                 self-adjusting computation and subject/observer
                 communication mechanisms, showing that the proposed
                 approach is efficient in practice.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Porter:2015:PFG,
  author =       "Donald E. Porter and Michael D. Bond and Indrajit Roy
                 and Kathryn S. Mckinley and Emmett Witchel",
  title =        "Practical Fine-Grained Information Flow Control Using
                 {Laminar}",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2638548",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 21 07:13:17 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Decentralized Information Flow Control (DIFC) is a
                 promising model for writing programs with powerful,
                 end-to-end security guarantees. Current DIFC systems
                 that run on commodity hardware can be broadly
                 categorized into two types: language-level and
                 operating system-level DIFC. Language solutions provide
                 no guarantees against security violations on system
                 resources such as files and sockets. Operating system
                 solutions mediate accesses to system resources but are
                 either inefficient or imprecise at monitoring the flow
                 of information through fine-grained program data
                 structures. This article describes Laminar, the first
                 system to implement DIFC using a unified set of
                 abstractions for OS resources and heap-allocated
                 objects. Programmers express security policies by
                 labeling data with secrecy and integrity labels and
                 access the labeled data in security methods. Laminar
                 enforces the security policies specified by the labels
                 at runtime. Laminar is implemented using a modified
                 Java virtual machine and a new Linux security module.
                 This article shows that security methods ease
                 incremental deployment and limit dynamic security
                 checks by retrofitting DIFC policies on four
                 application case studies. Replacing the applications'
                 ad hoc security policies changes less than 10\% of the
                 code and incurs performance overheads from 5\% to 56\%.
                 Compared to prior DIFC systems, Laminar supports a more
                 general class of multithreaded DIFC programs
                 efficiently and integrates language and OS
                 abstractions.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Frechtling:2015:MMS,
  author =       "Michael Frechtling and Philip H. W. Leong",
  title =        "{MCALIB}: Measuring Sensitivity to Rounding Error with
                 {Monte Carlo} Programming",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "2",
  pages =        "5:1--5:??",
  month =        apr,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2665073",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 18:32:12 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Runtime analysis provides an effective method for
                 measuring the sensitivity of programs to rounding
                 errors. To date, implementations have required
                 significant changes to source code, detracting from
                 their widespread application. In this work, we present
                 an open source system that automates the quantitative
                 analysis of floating point rounding errors through the
                 use of C-based source-to-source compilation and a Monte
                 Carlo arithmetic library. We demonstrate its
                 application to the comparison of algorithms, detection
                 of catastrophic cancellation, and determination of
                 whether single precision floating point provides
                 sufficient accuracy for a given application. Methods
                 for obtaining quantifiable measurements of sensitivity
                 to rounding error are also detailed.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Patrignani:2015:SCP,
  author =       "Marco Patrignani and Pieter Agten and Raoul Strackx
                 and Bart Jacobs and Dave Clarke and Frank Piessens",
  title =        "Secure Compilation to Protected Module Architectures",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "2",
  pages =        "6:1--6:??",
  month =        apr,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2699503",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 18:32:12 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A fully abstract compiler prevents security features
                 of the source language from being bypassed by an
                 attacker operating at the target language level.
                 Unfortunately, developing fully abstract compilers is
                 very complex, and it is even more so when the target
                 language is an untyped assembly language. To provide a
                 fully abstract compiler that targets untyped assembly,
                 it has been suggested to extend the target language
                 with a protected module architecture-an assembly-level
                 isolation mechanism which can be found in
                 next-generation processors. This article provides a
                 fully abstract compilation scheme whose source language
                 is an object-oriented, high-level language and whose
                 target language is such an extended assembly language.
                 The source language enjoys features such as dynamic
                 memory allocation and exceptions. Secure compilation of
                 first-order method references, cross-package
                 inheritance, and inner classes is also presented.
                 Moreover, this article contains the formal proof of
                 full abstraction of the compilation scheme.
                 Measurements of the overhead introduced by the
                 compilation scheme indicate that it is negligible.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Appel:2015:VCP,
  author =       "Andrew W. Appel",
  title =        "Verification of a Cryptographic Primitive: {SHA-256}",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "2",
  pages =        "7:1--7:??",
  month =        apr,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2701415",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Apr 16 18:32:12 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article presents a full formal machine-checked
                 verification of a C program: the OpenSSL implementation
                 of SHA-256. This is an interactive proof of functional
                 correctness in the Coq proof assistant, using the
                 Verifiable C program logic. Verifiable C is a
                 separation logic for the C language, proved sound with
                 respect to the operational semantics for C, connected
                 to the CompCert verified optimizing C compiler.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kasikci:2015:ACD,
  author =       "Baris Kasikci and Cristian Zamfir and George Candea",
  title =        "Automated Classification of Data Races Under Both
                 Strong and Weak Memory Models",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "3",
  pages =        "8:1--8:??",
  month =        jun,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2734118",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 19 05:36:55 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Data races are one of the main causes of concurrency
                 problems in multithreaded programs. Whether all data
                 races are bad, or some are harmful and others are
                 harmless, is still the subject of vigorous scientific
                 debate [Narayanasamy et al. 2007; Boehm 2012]. What is
                 clear, however, is that today's code has many data
                 races [Kasikci et al. 2012; Jin et al. 2012; Erickson
                 et al. 2010], and fixing data races without introducing
                 bugs is time consuming [Godefroid and Nagappan 2008].
                 Therefore, it is important to efficiently identify data
                 races in code and understand their consequences to
                 prioritize their resolution. We present Portend$^+$, a
                 tool that not only detects races but also automatically
                 classifies them based on their potential consequences:
                 Could they lead to crashes or hangs? Could their
                 effects be visible outside the program? Do they appear
                 to be harmless? How do their effects change under weak
                 memory models? Our proposed technique achieves high
                 accuracy by efficiently analyzing multiple paths and
                 multiple thread schedules in combination, and by
                 performing symbolic comparison between program outputs.
                 We ran Portend$^+$ on seven real-world applications: it
                 detected 93 true data races and correctly classified 92
                 of them, with no human effort. Six of them were harmful
                 races. Portend$^+$ 's classification accuracy is up to
                 89\% higher than that of existing tools, and it
                 produces easy-to-understand evidence of the
                 consequences of ``harmful'' races, thus both proving
                 their harmfulness and making debugging easier. We
                 envision Portend$^+$ being used for testing and
                 debugging, as well as for automatically triaging bug
                 reports.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wang:2015:EAS,
  author =       "Farn Wang and Sven Schewe and Chung-Hao Huang",
  title =        "An Extension of {ATL} with Strategy Interaction",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "3",
  pages =        "9:1--9:??",
  month =        jun,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2734117",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 19 05:36:55 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose an extension to ATL ( alternating-time
                 temporal logic ), called BSIL ( basic
                 strategy-interaction logic ), for specifying
                 collaboration among agents in a multiagent system. We
                 show that BSIL is strictly more expressive than ATL$^+$
                 but incomparable with ATL$^*$, GL ( game logic ), and
                 AMC ( alternating \mu -calculus ) in expressiveness. We
                 show that a memoryful strategy is necessary for
                 fulfilling a specification in BSIL. We establish that
                 the BSIL model-checking problem is PSPACE-complete.
                 However, BSIL model checking can be performed in time
                 quadratic in the model for fixed formulas. The BSIL
                 (and hence ATL$^+$ ) satisfiability is
                 2EXPTIME-complete. Finally, we report our experiment
                 with a model checker for BSIL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Betts:2015:DIV,
  author =       "Adam Betts and Nathan Chong and Alastair F. Donaldson
                 and Jeroen Ketema and Shaz Qadeer and Paul Thomson and
                 John Wickerson",
  title =        "The Design and Implementation of a Verification
                 Technique for {GPU} Kernels",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "3",
  pages =        "10:1--10:??",
  month =        jun,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2743017",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jun 19 05:36:55 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a technique for the formal verification of
                 GPU kernels, addressing two classes of correctness
                 properties: data races and barrier divergence. Our
                 approach is founded on a novel formal operational
                 semantics for GPU kernels termed {\em synchronous,
                 delayed visibility (SDV)\/} semantics, which captures
                 the execution of a GPU kernel by multiple groups of
                 threads. The SDV semantics provides operational
                 definitions for barrier divergence and for both inter-
                 and intra-group data races. We build on the semantics
                 to develop a method for reducing the task of verifying
                 a massively parallel GPU kernel to that of verifying a
                 sequential program. This completely avoids the need to
                 reason about thread interleavings, and allows existing
                 techniques for sequential program verification to be
                 leveraged. We describe an efficient encoding of data
                 race detection and propose a method for automatically
                 inferring the loop invariants that are required for
                 verification. We have implemented these techniques as a
                 practical verification tool, GPUVerify, that can be
                 applied directly to OpenCL and CUDA source code. We
                 evaluate GPUVerify with respect to a set of 162 kernels
                 drawn from public and commercial sources. Our
                 evaluation demonstrates that GPUVerify is capable of
                 efficient, automatic verification of a large number of
                 real-world kernels.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bugliesi:2015:ART,
  author =       "Michele Bugliesi and Stefano Calzavara and Fabienne
                 Eigner and Matteo Maffei",
  title =        "Affine Refinement Types for Secure Distributed
                 Programming",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "4",
  pages =        "11:1--11:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2743018",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 13 17:33:50 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Recent research has shown that it is possible to
                 leverage general-purpose theorem-proving techniques to
                 develop powerful type systems for the verification of a
                 wide range of security properties on application code.
                 Although successful in many respects, these type
                 systems fall short of capturing resource-conscious
                 properties that are crucial in large classes of modern
                 distributed applications. In this article, we propose
                 the first type system that statically enforces the
                 safety of cryptographic protocol implementations with
                 respect to authorization policies expressed in affine
                 logic. Our type system draws on a novel notion of
                 ``exponential serialization'' of affine formulas, a
                 general technique to protect affine formulas from the
                 effect of duplication. This technique allows formulate
                 of an expressive logical encoding of the authentication
                 mechanisms underpinning distributed resource-aware
                 authorization policies. We discuss the effectiveness of
                 our approach on two case studies: the EPMO e-commerce
                 protocol and the Kerberos authentication protocol. We
                 finally devise a sound and complete type-checking
                 algorithm, which is the key to achieving an efficient
                 implementation of our analysis technique.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grosser:2015:PAG,
  author =       "Tobias Grosser and Sven Verdoolaege and Albert Cohen",
  title =        "Polyhedral {AST} Generation Is More Than Scanning
                 Polyhedra",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "4",
  pages =        "12:1--12:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2743016",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 13 17:33:50 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Abstract mathematical representations such as integer
                 polyhedra have been shown to be useful to precisely
                 analyze computational kernels and to express complex
                 loop transformations. Such transformations rely on
                 abstract syntax tree (AST) generators to convert the
                 mathematical representation back to an imperative
                 program. Such generic AST generators avoid the need to
                 resort to transformation-specific code generators,
                 which may be very costly or technically difficult to
                 develop as transformations become more complex.
                 Existing AST generators have proven their
                 effectiveness, but they hit limitations in more complex
                 scenarios. Specifically, (1) they do not support or may
                 fail to generate control flow for complex
                 transformations using piecewise schedules or mappings
                 involving modulo arithmetic; (2) they offer limited
                 support for the specialization of the generated code
                 exposing compact, straightline, vectorizable kernels
                 with high arithmetic intensity necessary to exploit the
                 peak performance of modern hardware; (3) they offer no
                 support for memory layout transformations; and (4) they
                 provide insufficient control over the AST generation
                 strategy, preventing their application to complex
                 domain-specific optimizations. We present a new AST
                 generation approach that extends classical polyhedral
                 scanning to the full generality of Presburger
                 arithmetic, including existentially quantified
                 variables and piecewise schedules, and introduce new
                 optimizations for the detection of components and
                 shifted strides. Not limiting ourselves to control flow
                 generation, we expose functionality to generate AST
                 expressions from arbitrary piecewise quasi-affine
                 expressions, which enables the use of our AST generator
                 for data-layout transformations. We complement this
                 with support for specialization by polyhedral
                 unrolling, user-directed versioning, and specialization
                 of AST expressions according to the location at which
                 they are generated, and we complete this work with
                 fine-grained user control over the AST generation
                 strategies used. Using this generalized idea of AST
                 generation, we present how to implement complex
                 domain-specific transformations without the need to
                 write specialized code generators, but instead relying
                 on a generic AST generator parametrized to a specific
                 problem domain.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leavens:2015:BSS,
  author =       "Gary T. Leavens and David A. Naumann",
  title =        "Behavioral Subtyping, Specification Inheritance, and
                 Modular Reasoning",
  journal =      j-TOPLAS,
  volume =       "37",
  number =       "4",
  pages =        "13:1--13:??",
  month =        aug,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2766446",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 13 17:33:50 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Verification of a dynamically dispatched method call,
                 E.m(), seems to depend on E's dynamic type. To avoid
                 case analysis and allow incremental development,
                 object-oriented program verification uses supertype
                 abstraction. In other words, one reasons about E.m()
                 using m 's specification for E's static type. Supertype
                 abstraction is valid when each subtype in the program
                 is a behavioral subtype. This article semantically
                 formalizes supertype abstraction and behavioral
                 subtyping for a Java-like sequential language with
                 mutation and proves that behavioral subtyping is both
                 necessary and sufficient for the validity of supertype
                 abstraction. Specification inheritance, as in JML, is
                 also formalized and proved to entail behavioral
                 subtyping.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dantoni:2015:FTB,
  author =       "Loris D'antoni and Margus Veanes and Benjamin Livshits
                 and David Molnar",
  title =        "{Fast}: a Transducer-Based Language for Tree
                 Manipulation",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "1",
  pages =        "1:1--1:??",
  month =        oct,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2791292",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Oct 17 18:21:57 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Tree automata and transducers are used in a wide range
                 of applications in software engineering. While these
                 formalisms are of immense practical use, they can only
                 model finite alphabets. To overcome this problem we
                 augment tree automata and transducers with symbolic
                 alphabets represented as parametric theories. Admitting
                 infinite alphabets makes these models more general and
                 succinct than their classic counterparts. Despite this,
                 we show how the main operations, such as composition
                 and language equivalence, remain computable given a
                 decision procedure for the alphabet theory. We
                 introduce a high-level language called Fast that acts
                 as a front-end for the preceding formalisms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Biernacki:2015:DCP,
  author =       "Dariusz Biernacki and Olivier Danvy and Kevin
                 Millikin",
  title =        "A Dynamic Continuation-Passing Style for Dynamic
                 Delimited Continuations",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "1",
  pages =        "2:1--2:??",
  month =        oct,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2794078",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Oct 17 18:21:57 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We put a preexisting definitional abstract machine for
                 dynamic delimited continuations in defunctionalized
                 form, and we present the consequences of this
                 adjustment. We first prove the correctness of the
                 adjusted abstract machine. Because it is in
                 defunctionalized form, we can refunctionalize it into a
                 higher-order evaluation function. This evaluation
                 function, which is compositional, is in
                 continuation+state-passing style and threads a trail of
                 delimited continuations and a meta-continuation. Since
                 this style accounts for dynamic delimited
                 continuations, we refer to it as ``dynamic
                 continuation-passing style'' and we present the
                 corresponding dynamic CPS transformation. We show that
                 the notion of computation induced by dynamic CPS takes
                 the form of a continuation monad with a recursive
                 answer type. This continuation monad suggests a new
                 simulation of dynamic delimited continuations in terms
                 of static ones. Finally, we present new applications of
                 dynamic delimited continuations, including a
                 meta-circular evaluator. The significance of the
                 present work is that the computational artifacts
                 surrounding dynamic CPS are not independent designs:
                 they are mechanical consequences of having put the
                 definitional abstract machine in defunctionalized
                 form.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gesbert:2015:LAD,
  author =       "Nils Gesbert and Pierre Genev{\`e}s and Nabil
                 Laya{\"\i}da",
  title =        "A Logical Approach to Deciding Semantic Subtyping",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "1",
  pages =        "3:1--3:??",
  month =        oct,
  year =         "2015",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2812805",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Oct 17 18:21:57 MDT 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We consider a type algebra equipped with recursive,
                 product, function, intersection, union, and complement
                 types, together with type variables. We consider the
                 subtyping relation defined by Castagna and Xu [2011]
                 over such type expressions and show how this relation
                 can be decided in EXPTIME, answering an open question.
                 The novelty, originality and strength of our solution
                 reside in introducing a logical modeling for the
                 semantic subtyping framework. We model semantic
                 subtyping in a tree logic and use a
                 satisfiability-testing algorithm in order to decide
                 subtyping. We report on practical experiments made with
                 a full implementation of the system. This provides a
                 powerful polymorphic type system aiming at maintaining
                 full static type-safety of functional programs that
                 manipulate trees, even with higher-order functions,
                 which is particularly useful in the context of XML.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dodds:2016:VCS,
  author =       "Mike Dodds and Suresh Jagannathan and Matthew J.
                 Parkinson and Kasper Svendsen and Lars Birkedal",
  title =        "Verifying Custom Synchronization Constructs Using
                 Higher-Order Separation Logic",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "2",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2818638",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 5 16:31:06 MST 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Synchronization constructs lie at the heart of any
                 reliable concurrent program. Many such constructs are
                 standard (e.g., locks, queues, stacks, and
                 hash-tables). However, many concurrent applications
                 require custom synchronization constructs with
                 special-purpose behavior. These constructs present a
                 significant challenge for verification. Like standard
                 constructs, they rely on subtle racy behavior, but
                 unlike standard constructs, they may not have
                 well-understood abstract interfaces. As they are custom
                 built, such constructs are also far more likely to be
                 unreliable. This article examines the formal
                 specification and verification of custom
                 synchronization constructs. Our target is a library of
                 channels used in automated parallelization to enforce
                 sequential behavior between program statements. Our
                 high-level specification captures the conditions
                 necessary for correct execution; these conditions
                 reflect program dependencies necessary to ensure
                 sequential behavior. We connect the high-level
                 specification with the low-level library implementation
                 to prove that a client's requirements are satisfied.
                 Significantly, we can reason about program and library
                 correctness without breaking abstraction boundaries. To
                 achieve this, we use a program logic called iCAP
                 (impredicative Concurrent Abstract Predicates) based on
                 separation logic. iCAP supports both high-level
                 abstraction and low-level reasoning about races. We use
                 this to show that our high-level channel specification
                 abstracts three different, increasingly complex
                 low-level implementations of the library. iCAP's
                 support for higher-order reasoning lets us prove that
                 sequential dependencies are respected, while iCAP's
                 next-generation semantic model lets us avoid ugly
                 problems with cyclic dependencies.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Yiapanis:2016:CDS,
  author =       "Paraskevas Yiapanis and Gavin Brown and Mikel
                 Luj{\'a}n",
  title =        "Compiler-Driven Software Speculation for Thread-Level
                 Parallelism",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "2",
  pages =        "5:1--5:??",
  month =        jan,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2821505",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 5 16:31:06 MST 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Current parallelizing compilers can tackle
                 applications exercising regular access patterns on
                 arrays or affine indices, where data dependencies can
                 be expressed in a linear form. Unfortunately, there are
                 cases that independence between statements of code
                 cannot be guaranteed and thus the compiler
                 conservatively produces sequential code. Programs that
                 involve extensive pointer use, irregular access
                 patterns, and loops with unknown number of iterations
                 are examples of such cases. This limits the extraction
                 of parallelism in cases where dependencies are rarely
                 or never triggered at runtime. Speculative parallelism
                 refers to methods employed during program execution
                 that aim to produce a valid parallel execution schedule
                 for programs immune to static parallelization. The
                 motivation for this article is to review recent
                 developments in the area of compiler-driven software
                 speculation for thread-level parallelism and how they
                 came about. The article is divided into two parts. In
                 the first part the fundamentals of speculative
                 parallelization for thread-level parallelism are
                 explained along with a design choice categorization for
                 implementing such systems. Design choices include the
                 ways speculative data is handled, how data dependence
                 violations are detected and resolved, how the correct
                 data are made visible to other threads, or how
                 speculative threads are scheduled. The second part is
                 structured around those design choices providing the
                 advances and trends in the literature with reference to
                 key developments in the area. Although the focus of the
                 article is in software speculative parallelization, a
                 section is dedicated for providing the interested
                 reader with pointers and references for exploring
                 similar topics such as hardware thread-level
                 speculation, transactional memory, and automatic
                 parallelization.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Oh:2016:SXS,
  author =       "Hakjoo Oh and Wonchan Lee and Kihong Heo and Hongseok
                 Yang and Kwangkeun Yi",
  title =        "Selective {X}-Sensitive Analysis Guided by Impact
                 Pre-Analysis",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "2",
  pages =        "6:1--6:??",
  month =        jan,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2821504",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 5 16:31:06 MST 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a method for selectively applying
                 context-sensitivity during interprocedural program
                 analysis. Our method applies context-sensitivity only
                 when and where doing so is likely to improve the
                 precision that matters for resolving given queries. The
                 idea is to use a pre-analysis to estimate the impact of
                 context-sensitivity on the main analysis's precision,
                 and to use this information to find out when and where
                 the main analysis should turn on or off its
                 context-sensitivity. We formalize this approach and
                 prove that the analysis always benefits from the
                 pre-analysis--guided context-sensitivity. We
                 implemented this selective method for an existing
                 industrial-strength interval analyzer for full C. The
                 method reduced the number of (false) alarms by 24.4\%
                 while increasing the analysis cost by 27.8\% on
                 average. The use of the selective method is not limited
                 to context-sensitivity. We demonstrate this generality
                 by following the same principle and developing a
                 selective relational analysis and a selective
                 flow-sensitive analysis. Our experiments show that the
                 method cost-effectively improves the precision in the
                 these analyses as well.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Dissegna:2016:AIB,
  author =       "Stefano Dissegna and Francesco Logozzo and Francesco
                 Ranzato",
  title =        "An Abstract Interpretation-Based Model of Tracing
                 Just-in-Time Compilation",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jan,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2853131",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Jan 5 16:31:06 MST 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Tracing just-in-time compilation is a popular
                 compilation technique for the efficient implementation
                 of dynamic languages, which is commonly used for
                 JavaScript, Python, and PHP. It relies on two key
                 ideas. First, it monitors program execution in order to
                 detect so-called hot paths, that is, the most
                 frequently executed program paths. Then, hot paths are
                 optimized by exploiting some information on program
                 stores that is available and therefore gathered at
                 runtime. The result is a residual program where the
                 optimized hot paths are guarded by sufficient
                 conditions ensuring some form of equivalence with the
                 original program. The residual program is persistently
                 mutated during its execution, for example, to add new
                 optimized hot paths or to merge existing paths. Tracing
                 compilation is thus fundamentally different from
                 traditional static compilation. Nevertheless, despite
                 the practical success of tracing compilation, very
                 little is known about its theoretical foundations. We
                 provide a formal model of tracing compilation of
                 programs using abstract interpretation. The monitoring
                 phase (viz., hot path detection) corresponds to an
                 abstraction of the trace semantics of the program that
                 captures the most frequent occurrences of sequences of
                 program points together with an abstraction of their
                 corresponding stores, for example, a type environment.
                 The optimization phase (viz., residual program
                 generation) corresponds to a transform of the original
                 program that preserves its trace semantics up to a
                 given observation as modeled by some abstraction. We
                 provide a generic framework to express dynamic
                 optimizations along hot paths and to prove them
                 correct. We instantiate it to prove the correctness of
                 dynamic type specialization and constant variable
                 folding. We show that our framework is more general
                 than the model of tracing compilation introduced by Guo
                 and Palsberg [2011], which is based on operational
                 bisimulations. In our model, we can naturally express
                 hot path reentrance and common optimizations like
                 dead-store elimination, which are either excluded or
                 unsound in Guo and Palsberg's framework.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ryu:2016:TOO,
  author =       "Sukyoung Ryu",
  title =        "{ThisType} for Object-Oriented Languages: From Theory
                 to Practice",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "3",
  pages =        "8:1--8:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2888392",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 16:24:58 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In object-oriented programs, objects often provide
                 methods whose parameter types or return types are the
                 object types themselves. For example, the parameter
                 types of binary methods are the types of their receiver
                 objects, and the return types of some factory methods
                 are the types of their enclosing objects. However, most
                 object-oriented languages do not support such methods
                 precisely because their type systems do not support
                 explicit recursive types, which lead to a mismatch
                 between subclassing and subtyping. This mismatch means
                 that an expression of a subclass may not always be
                 usable in a context where an expression of a superclass
                 is expected, which is not intuitive in an
                 object-oriented setting. Researchers have proposed
                 various type-sound approaches to support methods with
                 types of their enclosing object types denoted by some
                 variants of ThisType, but they reject reasonable and
                 useful methods due to unpermissive type systems or they
                 use less precise declared inexact types rather than
                 runtime exact types. In this article, we present a
                 thorough approach to support methods with ThisTypes:
                 from a new encoding of objects in a typed lambda
                 calculus that allows subtyping by subclassing to an
                 open-source implementation as an extension of the Java
                 programming language. We first provide real-world
                 examples that motivate the need for ThisTyped methods
                 to precisely describe desired properties of programs.
                 We define a new object encoding that enables subtyping
                 by subclassing even in the presence of negative
                 occurrences of type recursion variables by
                 distinguishing object types from existential object
                 types. Based on this object encoding, we formalize
                 language features to support ThisTyped methods with a
                 core calculus CoreThisJava, and prove its type
                 soundness. Finally, we provide ThisJava, a prototype
                 implementation of the calculus, to show its backward
                 compatibility, and we make it publicly available. We
                 believe that our approach theoretically expands the
                 long pursuit of an object-oriented language with
                 ThisTypes to support more useful methods with more
                 precise types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wagner:2016:TIB,
  author =       "Gregor Wagner and Per Larsen and Stefan Brunthaler and
                 Michael Franz",
  title =        "Thinking Inside the Box: Compartmentalized Garbage
                 Collection",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "3",
  pages =        "9:1--9:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2866576",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 16:24:58 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The web browser is the ``new desktop.'' Not only do
                 many users spend most of their time using the browser,
                 the browser has also become host to rich and dynamic
                 applications that were previously tailored to each
                 individual operating system. The lingua franca of web
                 scripting, JavaScript, was pivotal in this development.
                 Imagine that all desktop applications allocated memory
                 from a single heap managed by the operating system. To
                 reclaim memory upon application shutdown, all processes
                 would then be garbage collected-not just the one being
                 quit. While operating systems improved upon this
                 approach long ago, this was how browsers managed memory
                 until recently. This article explores compartmentalized
                 memory management, an approach tailored specifically to
                 web browsers. The idea is to partition the JavaScript
                 heap into compartments and allocate objects to
                 compartments based on their origin. All objects in the
                 same compartment reference each other direct, whereas
                 cross-origin references go through wrapper objects. We
                 carefully evaluate our techniques using Mozilla's
                 Firefox browser-which now ships with our
                 enhancements-and demonstrate the benefits of collecting
                 each compartment independently. This simultaneously
                 improves runtime performance (up to 36\%) and reduces
                 garbage collection pause times (up to 75\%) as well as
                 the memory footprint of the browser. In addition,
                 enforcing the same-origin security policy becomes
                 simple and efficient with compartments.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Norris:2016:PAM,
  author =       "Brian Norris and Brian Demsky",
  title =        "A Practical Approach for Model Checking {C\slash
                 C++11} Code",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "3",
  pages =        "10:1--10:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2806886",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 16:24:58 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Writing low-level concurrent software has
                 traditionally required intimate knowledge of the entire
                 toolchain and often has involved coding in assembly.
                 New language standards have extended C and C++ with
                 support for low-level atomic operations and a weak
                 memory model, enabling developers to write portable and
                 efficient multithreaded code. In this article, we
                 present CDSChecker, a tool for exhaustively exploring
                 the behaviors of concurrent code under the C/C++ memory
                 model. We have used CDSChecker to exhaustively unit
                 test concurrent data structure implementations and have
                 discovered errors in a published implementation of a
                 work-stealing queue and a single producer, single
                 consumer queue.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bhaskaracharya:2016:ASO,
  author =       "Somashekaracharya G. Bhaskaracharya and Uday
                 Bondhugula and Albert Cohen",
  title =        "Automatic Storage Optimization for Arrays",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "3",
  pages =        "11:1--11:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2845078",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 16:24:58 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Efficient memory allocation is crucial for
                 data-intensive applications, as a smaller memory
                 footprint ensures better cache performance and allows
                 one to run a larger problem size given a fixed amount
                 of main memory. In this article, we describe a new
                 automatic storage optimization technique to minimize
                 the dimensionality and storage requirements of arrays
                 used in sequences of loop nests with a predetermined
                 schedule. We formulate the problem of intra-array
                 storage optimization as one of finding the right
                 storage partitioning hyperplanes: each storage
                 partition corresponds to a single storage location. Our
                 heuristic is driven by a dual-objective function that
                 minimizes both the dimensionality of the mapping and
                 the extents along those dimensions. The technique is
                 dimension optimal for most codes encountered in
                 practice. The storage requirements of the mappings
                 obtained also are asymptotically better than those
                 obtained by any existing schedule-dependent technique.
                 Storage reduction factors and other results that we
                 report from an implementation of our technique
                 demonstrate its effectiveness on several real-world
                 examples drawn from the domains of image processing,
                 stencil computations, high-performance computing, and
                 the class of tiled codes in general.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Bondhugula:2016:PAP,
  author =       "Uday Bondhugula and Aravind Acharya and Albert Cohen",
  title =        "The {Pluto+} Algorithm: a Practical Approach for
                 Parallelization and Locality Optimization of Affine
                 Loop Nests",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "3",
  pages =        "12:1--12:??",
  month =        may,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2896389",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon May 2 16:24:58 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Affine transformations have proven to be powerful for
                 loop restructuring due to their ability to model a very
                 wide range of transformations. A single
                 multidimensional affine function can represent a long
                 and complex sequence of simpler transformations.
                 Existing affine transformation frameworks such as the
                 Pluto algorithm, which include a cost function for
                 modern multicore architectures for which coarse-grained
                 parallelism and locality are crucial, consider only a
                 subspace of transformations to avoid a combinatorial
                 explosion in finding transformations. The ensuing
                 practical trade-offs lead to the exclusion of certain
                 useful transformations: in particular, transformation
                 compositions involving loop reversals and loop skewing
                 by negative factors. In addition, there is currently no
                 proof that the algorithm successfully finds a tree of
                 permutable loop bands for all affine loop nests. In
                 this article, we propose an approach to address these
                 two issues (1) by modeling a much larger space of
                 practically useful affine transformations in
                 conjunction with the existing cost function of Pluto,
                 and (2) by extending the Pluto algorithm in a way that
                 allows a proof for its soundness and completeness for
                 all affine loop nests. We perform an experimental
                 evaluation of both, the effect on compilation time, and
                 performance of generated codes. The evaluation shows
                 that our new framework, Pluto+, provides no degradation
                 in performance for any benchmark from Polybench. For
                 the Lattice Boltzmann Method (LBM) simulations with
                 periodic boundary conditions, it provides a mean
                 speedup of 1.33 $ \times $ over Pluto. We also show
                 that Pluto+ does not increase compilation time
                 significantly. Experimental results on Polybench show
                 that Pluto+ increases overall polyhedral
                 source-to-source optimization time by only 15\%. In
                 cases in which it improves execution time
                 significantly, it increased polyhedral optimization
                 time by only 2.04 $ \times $ .",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Brockschmidt:2016:ARS,
  author =       "Marc Brockschmidt and Fabian Emmes and Stephan Falke
                 and Carsten Fuhs and J{\"u}rgen Giesl",
  title =        "Analyzing Runtime and Size Complexity of Integer
                 Programs",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "4",
  pages =        "13:1--13:??",
  month =        oct,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2866575",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 18 11:41:44 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a modular approach to automatic complexity
                 analysis of integer programs. Based on a novel
                 alternation between finding symbolic time bounds for
                 program parts and using these to infer bounds on the
                 absolute values of program variables, we can restrict
                 each analysis step to a small part of the program while
                 maintaining a high level of precision. The bounds
                 computed by our method are polynomial or exponential
                 expressions that depend on the absolute values of input
                 parameters. We show how to extend our approach to
                 arbitrary cost measures, allowing the use of our
                 technique to find upper bounds for other expended
                 resources, such as network requests or memory
                 consumption. Our contributions are implemented in the
                 open-source tool KoAT, and extensive experiments show
                 the performance and power of our implementation in
                 comparison with other tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Balabonski:2016:DFM,
  author =       "Thibaut Balabonski and Fran{\c{c}}ois Pottier and
                 Jonathan Protzenko",
  title =        "The Design and Formalization of {Mezzo}, a
                 Permission-Based Programming Language",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "4",
  pages =        "14:1--14:??",
  month =        oct,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2837022",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 18 11:41:44 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The programming language Mezzo is equipped with a rich
                 type system that controls aliasing and access to
                 mutable memory. We give a comprehensive tutorial
                 overview of the language. Then we present a modular
                 formalization of Mezzo's core type system, in the form
                 of a concurrent $ \lambda $-calculus, which we
                 successively extend with references, locks, and
                 adoption and abandon, a novel mechanism that marries
                 Mezzo's static ownership discipline with dynamic
                 ownership tests. We prove that well-typed programs do
                 not go wrong and are data-race free. Our definitions
                 and proofs are machine checked.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Blackburn:2016:TWT,
  author =       "Stephen M. Blackburn and Amer Diwan and Matthias
                 Hauswirth and Peter F. Sweeney and Jos{\'e} Nelson
                 Amaral and Tim Brecht and Lubom{\'\i}r Bulej and Cliff
                 Click and Lieven Eeckhout and Sebastian Fischmeister
                 and Daniel Frampton and Laurie J. Hendren and Michael
                 Hind and Antony L. Hosking and Richard E. Jones and
                 Tomas Kalibera and Nathan Keynes and Nathaniel Nystrom
                 and Andreas Zeller",
  title =        "The Truth, The Whole Truth, and Nothing But the Truth:
                 a Pragmatic Guide to Assessing Empirical Evaluations",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "4",
  pages =        "15:1--15:??",
  month =        oct,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2983574",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 18 11:41:44 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "An unsound claim can misdirect a field, encouraging
                 the pursuit of unworthy ideas and the abandonment of
                 promising ideas. An inadequate description of a claim
                 can make it difficult to reason about the claim, for
                 example, to determine whether the claim is sound. Many
                 practitioners will acknowledge the threat of unsound
                 claims or inadequate descriptions of claims to their
                 field. We believe that this situation is exacerbated,
                 and even encouraged, by the lack of a systematic
                 approach to exploring, exposing, and addressing the
                 source of unsound claims and poor exposition. This
                 article proposes a framework that identifies three sins
                 of reasoning that lead to unsound claims and two sins
                 of exposition that lead to poorly described claims and
                 evaluations. Sins of exposition obfuscate the objective
                 of determining whether or not a claim is sound, while
                 sins of reasoning lead directly to unsound claims. Our
                 framework provides practitioners with a principled way
                 of critiquing the integrity of their own work and the
                 work of others. We hope that this will help individuals
                 conduct better science and encourage a cultural shift
                 in our research community to identify and promulgate
                 sound claims.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Marino:2016:DXU,
  author =       "Daniel Marino and Abhayendra Singh and Todd Millstein
                 and Madanlal Musuvathi and Satish Narayanasamy",
  title =        "{drf x}: an Understandable, High Performance, and
                 Flexible Memory Model for Concurrent Languages",
  journal =      j-TOPLAS,
  volume =       "38",
  number =       "4",
  pages =        "16:1--16:??",
  month =        oct,
  year =         "2016",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2925988",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Oct 18 11:41:44 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The most intuitive memory model for shared-memory
                 multi-threaded programming is sequential consistency
                 (SC), but it disallows the use of many compiler and
                 hardware optimizations and thus affects performance.
                 Data-race-free (DRF) models, such as the C++11 memory
                 model, guarantee SC execution for data-race-free
                 programs. But these models provide no guarantee at all
                 for racy programs, compromising the safety and
                 debuggability of such programs. To address the safety
                 issue, the Java memory model, which is also based on
                 the DRF model, provides a weak semantics for racy
                 executions. However, this semantics is subtle and
                 complex, making it difficult for programmers to reason
                 about their programs and for compiler writers to ensure
                 the correctness of compiler optimizations. We present
                 the drf x memory model, which is simple for programmers
                 to understand and use while still supporting many
                 common optimizations. We introduce a memory model (MM)
                 exception that can be signaled to halt execution. If a
                 program executes without throwing this exception, then
                 drf x guarantees that the execution is SC. If a program
                 throws an MM exception during an execution, then drf x
                 guarantees that the program has a data race. We observe
                 that SC violations can be detected in hardware through
                 a lightweight form of conflict detection. Furthermore,
                 our model safely allows aggressive compiler and
                 hardware optimizations within compiler-designated
                 program regions. We formalize our memory model, prove
                 several properties of this model, describe a compiler
                 and hardware design suitable for drf x, and evaluate
                 the performance overhead due to our compiler and
                 hardware requirements.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Myers:2017:F,
  author =       "Andrew Myers",
  title =        "Foreword",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "1",
  pages =        "1:1--1:??",
  month =        mar,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3052720",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cohen:2017:LPC,
  author =       "Nachshon Cohen and Erez Petrank",
  title =        "Limitations of Partial Compaction: Towards Practical
                 Bounds",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "1",
  pages =        "2:1--2:??",
  month =        mar,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2994597",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Compaction of a managed heap is a costly operation to
                 be avoided as much as possible in commercial runtimes.
                 Instead, partial compaction is often used to defragment
                 parts of the heap and avoid space blowup. Previous
                 study of compaction limitation provided some initial
                 asymptotic bounds but no implications for practical
                 systems. In this work, we extend the theory to obtain
                 better bounds and make them strong enough to become
                 meaningful for modern systems.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sekiyama:2017:PMC,
  author =       "Taro Sekiyama and Atsushi Igarashi and Michael
                 Greenberg",
  title =        "Polymorphic Manifest Contracts, Revised and Resolved",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "1",
  pages =        "3:1--3:??",
  month =        mar,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2994594",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:47:08 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Manifest contracts track precise program properties by
                 refining types with predicates-for example, $ \{ x :
                 {\rm Int} | x > 0 \} $ denotes the positive integers.
                 Contracts and polymorphism make a natural combination:
                 programmers can give strong contracts to abstract
                 types, precisely stating pre- and post conditions while
                 hiding implementation details- for instance, an
                 abstract type of stacks might specify that the pop
                 operation has input type $ \{ x : \alpha {\rm Stack} |
                 {\rm not} ({\rm empty} x) \} $. This article studies a
                 polymorphic calculus with manifest contracts and
                 establishes fundamental properties including type
                 soundness and relational parametricity. Indeed, this is
                 not the first work on polymorphic manifest contracts,
                 but existing calculi are not very satisfactory. Gronski
                 et al. developed the S age language, which introduces
                 polymorphism through the Type:Type discipline, but they
                 do not study parametricity. Some authors of this
                 article have produced two separate works: Belo et al.
                 [2011] and Greenberg [2013] studied polymorphic
                 manifest contracts and parametricity, but their calculi
                 have metatheoretical problems in the type conversion
                 relations. Indeed, they depend on a few conjectures,
                 which turn out to be false. Our calculus is the first
                 polymorphic manifest calculus with parametricity,
                 depending on no conjectures-it resolves the issues in
                 prior calculi with delayed substitution on casts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ligatti:2017:SRC,
  author =       "Jay Ligatti and Jeremy Blackburn and Michael
                 Nachtigal",
  title =        "On Subtyping-Relation Completeness, with an
                 Application to Iso-Recursive Types",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "1",
  pages =        "4:1--4:??",
  month =        mar,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2994596",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Well-known techniques exist for proving the soundness
                 of subtyping relations with respect to type safety.
                 However, completeness has not been treated with widely
                 applicable techniques, as far as we're aware. This
                 article develops techniques for stating and proving
                 that a subtyping relation is complete with respect to
                 type safety and applies the techniques to the study of
                 iso-recursive subtyping. A new proof technique,
                 induction on failing derivations, is provided that may
                 be useful in other domains as well. The common
                 subtyping rules for iso-recursive types-the ``Amber
                 rules''-are shown to be incomplete with respect to type
                 safety. That is, there exist iso-recursive types $
                 \tau_1 $ and $ \tau_2 $ such that $ \tau_1 $ can safely
                 be considered a subtype of $ \tau_2 $, but $ \tau_1
                 \leq \tau_2 $ is not derivable with the Amber rules.
                 New, algorithmic rules are defined for subtyping
                 iso-recursive types, and the rules are proved sound and
                 complete with respect to type safety. The fully
                 implemented subtyping algorithm is optimized to run in
                 $ O(m n) $ time, where $m$ is the number of $ \mu $
                 -terms in the types being considered and $n$ is the
                 size of the types being considered.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hirzel:2017:SEL,
  author =       "Martin Hirzel and Scott Schneider and Bugra Gedik",
  title =        "{SPL}: an Extensible Language for Distributed Stream
                 Processing",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "1",
  pages =        "5:1--5:??",
  month =        mar,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3039207",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Big data is revolutionizing how all sectors of our
                 economy do business, including telecommunication,
                 transportation, medical, and finance. Big data comes in
                 two flavors: data at rest and data in motion.
                 Processing data in motion is stream processing. Stream
                 processing for big data analytics often requires scale
                 that can only be delivered by a distributed system,
                 exploiting parallelism on many hosts and many cores.
                 One such distributed stream processing system is IBM
                 Streams. Early customer experience with IBM Streams
                 uncovered that another core requirement is
                 extensibility, since customers want to build
                 high-performance domain-specific operators for use in
                 their streaming applications. Based on these two core
                 requirements of distribution and extensibility, we
                 designed and implemented the Streams Processing
                 Language (SPL). This article describes SPL with an
                 emphasis on the language design, distributed runtime,
                 and extensibility mechanism. SPL is now the gateway for
                 the IBM Streams platform, used by our customers for
                 stream processing in a broad range of application
                 domains.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Alglave:2017:DSF,
  author =       "Jade Alglave and Daniel Kroening and Vincent Nimal and
                 Daniel Poetzl",
  title =        "Don't Sit on the Fence: a Static Analysis Approach to
                 Automatic Fence Insertion",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "2",
  pages =        "6:1--6:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2994593",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Modern architectures rely on memory fences to prevent
                 undesired weakenings of memory consistency. As the
                 fences' semantics may be subtle, the automation of
                 their placement is highly desirable. But precise
                 methods for restoring consistency do not scale to
                 deployed systems' code. We choose to trade some
                 precision for genuine scalability: our technique is
                 suitable for large code bases. We implement it in our
                 new musketeer tool and report experiments on more than
                 700 executables from packages found in Debian GNU/Linux
                 7.1, including memcached with about 10,000 LoC.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jakobs:2017:PPF,
  author =       "Marie-Christine Jakobs and Heike Wehrheim",
  title =        "Programs from Proofs: a Framework for the Safe
                 Execution of Untrusted Software",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "2",
  pages =        "7:1--7:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3014427",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Today, software is traded worldwide on global markets,
                 with apps being downloaded to smartphones within
                 minutes or seconds. This poses, more than ever, the
                 challenge of ensuring safety of software in the face of
                 (1) unknown or untrusted software providers together
                 with (2) resource-limited software consumers. The
                 concept of Proof-Carrying Code (PCC), years ago
                 suggested by Necula, provides one framework for
                 securing the execution of untrusted code. PCC
                 techniques attach safety proofs, constructed by
                 software producers, to code. Based on the assumption
                 that checking proofs is usually much simpler than
                 constructing proofs, software consumers should thus be
                 able to quickly check the safety of software. However,
                 PCC techniques often suffer from the size of
                 certificates (i.e., the attached proofs), making PCC
                 techniques inefficient in practice. In this article, we
                 introduce a new framework for the safe execution of
                 untrusted code called Programs from Proofs (PfP). The
                 basic assumption underlying the PfP technique is the
                 fact that the structure of programs significantly
                 influences the complexity of checking a specific safety
                 property. Instead of attaching proofs to program code,
                 the PfP technique transforms the program into an
                 efficiently checkable form, thus guaranteeing quick
                 safety checks for software consumers. For this
                 transformation, the technique also uses a producer-side
                 automatic proof of safety. More specifically, safety
                 proving for the software producer proceeds via the
                 construction of an abstract reachability graph (ARG)
                 unfolding the control-flow automaton (CFA) up to the
                 degree necessary for simple checking. To this end, we
                 combine different sorts of software analysis: expensive
                 analyses incrementally determining the degree of
                 unfolding, and cheap analyses responsible for safety
                 checking. Out of the abstract reachability graph we
                 generate the new program. In its CFA structure, it is
                 isomorphic to the graph and hence another, this time
                 consumer-side, cheap analysis can quickly determine its
                 safety. Like PCC, Programs from Proofs is a general
                 framework instantiable with different sorts of
                 (expensive and cheap) analysis. Here, we present the
                 general framework and exemplify it by some concrete
                 examples. We have implemented different instantiations
                 on top of the configurable program analysis tool CPA
                 checker and report on experiments, in particular on
                 comparisons with PCC techniques.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Darulova:2017:TCR,
  author =       "Eva Darulova and Viktor Kuncak",
  title =        "Towards a Compiler for Reals",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "2",
  pages =        "8:1--8:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3014426",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Numerical software, common in scientific computing or
                 embedded systems, inevitably uses a finite-precision
                 approximation of the real arithmetic in which most
                 algorithms are designed. In many applications, the
                 roundoff errors introduced by finite-precision
                 arithmetic are not the only source of inaccuracy, and
                 measurement and other input errors further increase the
                 uncertainty of the computed results. Adequate tools are
                 needed to help users select suitable data types and
                 evaluate the provided accuracy, especially for
                 safety-critical applications. We present a
                 source-to-source compiler called Rosa that takes as
                 input a real-valued program with error specifications
                 and synthesizes code over an appropriate floating-point
                 or fixed-point data type. The main challenge of such a
                 compiler is a fully automated, sound, and yet
                 accurate-enough numerical error estimation. We
                 introduce a unified technique for bounding roundoff
                 errors from floating-point and fixed-point arithmetic
                 of various precisions. The technique can handle
                 nonlinear arithmetic, determine closed-form symbolic
                 invariants for unbounded loops, and quantify the
                 effects of discontinuities on numerical errors. We
                 evaluate Rosa on a number of benchmarks from scientific
                 computing and embedded systems and, comparing it to the
                 state of the art in automated error estimation, show
                 that it presents an interesting tradeoff between
                 accuracy and performance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Reps:2017:NPA,
  author =       "Thomas Reps and Emma Turetsky and Prathmesh Prabhu",
  title =        "{Newtonian} Program Analysis via Tensor Product",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "2",
  pages =        "9:1--9:??",
  month =        may,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3024084",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:40 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Recently, Esparza et al. generalized Newton's method-a
                 numerical-analysis algorithm for finding roots of
                 real-valued functions-to a method for finding
                 fixed-points of systems of equations over semirings.
                 Their method provides a new way to solve
                 interprocedural dataflow-analysis problems. As in its
                 real-valued counterpart, each iteration of their method
                 solves a simpler ``linearized'' problem. One of the
                 reasons this advance is exciting is that some numerical
                 analysts have claimed that ```all' effective and fast
                 iterative [numerical] methods are forms (perhaps very
                 disguised) of Newton's method.'' However, there is an
                 important difference between the dataflow-analysis and
                 numerical-analysis contexts: When Newton's method is
                 used in numerical-analysis problems, commutativity of
                 multiplication is relied on to rearrange an expression
                 of the form `` a * X * b + c * X * d '' into ``( a * b
                 + c * d )* X.'' Equations with such expressions
                 correspond to path problems described by regular
                 languages. In contrast, when Newton's method is used
                 for interprocedural dataflow analysis, the
                 ``multiplication'' operation involves function
                 composition and hence is non-commutative: `` a * X * b
                 + c * X * d '' cannot be rearranged into ``( a * b + c
                 * d )* X.'' Equations with such expressions correspond
                 to path problems described by linear context-free
                 languages (LCFLs). In this article, we present an
                 improved technique for solving the LCFL sub-problems
                 produced during successive rounds of Newton's method.
                 Our method applies to predicate abstraction, on which
                 most of today's software model checkers rely.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Austin:2017:MFD,
  author =       "Thomas H. Austin and Tommy Schmitz and Cormac
                 Flanagan",
  title =        "Multiple Facets for Dynamic Information Flow with
                 Exceptions",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "3",
  pages =        "10:1--10:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3024086",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:41 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "JavaScript is the source of many security problems,
                 including cross-site scripting attacks and malicious
                 advertising code. Central to these problems is the fact
                 that code from untrusted sources runs with full
                 privileges. Information flow controls help prevent
                 violations of data confidentiality and integrity. This
                 article explores faceted values, a mechanism for
                 providing information flow security in a dynamic manner
                 that avoids the stuck executions of some prior
                 approaches, such as the no-sensitive-upgrade technique.
                 Faceted values simultaneously simulate multiple
                 executions for different security levels to guarantee
                 termination-insensitive noninterference. We also
                 explore the interaction of faceted values with
                 exceptions, declassification, and clearance.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gordon:2017:VIL,
  author =       "Colin S. Gordon and Michael D. Ernst and Dan Grossman
                 and Matthew J. Parkinson",
  title =        "Verifying Invariants of Lock-Free Data Structures with
                 Rely-Guarantee and Refinement Types",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "3",
  pages =        "11:1--11:??",
  month =        jul,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3064850",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Jul 24 09:44:41 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Verifying invariants of fine-grained concurrent data
                 structures is challenging, because interference from
                 other threads may occur at any time. We propose a new
                 way of proving invariants of fine-grained concurrent
                 data structures: applying rely-guarantee reasoning to
                 references in the concurrent setting. Rely-guarantee
                 applied to references can verify bounds on thread
                 interference without requiring a whole program to be
                 verified. This article provides three new results.
                 First, it provides a new approach to preserving
                 invariants and restricting usage of concurrent data
                 structures. Our approach targets a space between simple
                 type systems and modern concurrent program logics,
                 offering an intermediate point between unverified code
                 and full verification. Furthermore, it avoids sealing
                 concurrent data structure implementations and can
                 interact safely with unverified imperative code.
                 Second, we demonstrate the approach's broad
                 applicability through a series of case studies, using
                 two implementations: an axiomatic C oq domain-specific
                 language and a library for Liquid Haskell. Third, these
                 two implementations allow us to compare and contrast
                 verifications by interactive proof (Coq) and a weaker
                 form that can be expressed using
                 automatically-discharged dependent refinement types
                 (Liquid Haskell).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jourdan:2017:SPC,
  author =       "Jacques-Henri Jourdan and Fran{\c{c}}ois Pottier",
  title =        "A Simple, Possibly Correct {LR} Parser for {C11}",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "4",
  pages =        "14:1--14:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3064848",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 19 06:38:32 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  abstract =     "The syntax of the C programming language is described
                 in the C11 standard by an ambiguous context-free
                 grammar, accompanied with English prose that describes
                 the concept of ``scope'' and indicates how certain
                 ambiguous code fragments should be interpreted. Based
                 on these elements, the problem of implementing a
                 compliant C11 parser is not entirely trivial. We review
                 the main sources of difficulty and describe a
                 relatively simple solution to the problem. Our solution
                 employs the well-known technique of combining an
                 LALR(1) parser with a ``lexical feedback'' mechanism.
                 It draws on folklore knowledge and adds several
                 original aspects, including a twist on lexical feedback
                 that allows a smooth interaction with lookahead; a
                 simplified and powerful treatment of scopes; and a few
                 amendments in the grammar. Although not formally
                 verified, our parser avoids several pitfalls that other
                 implementations have fallen prey to. We believe that
                 its simplicity, its mostly declarative nature, and its
                 high similarity with the C11 grammar are strong
                 informal arguments in favor of its correctness. Our
                 parser is accompanied with a small suite of ``tricky''
                 C11 programs. We hope that it may serve as a reference
                 or a starting point in the implementation of compilers
                 and analysis tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Forejt:2017:PPA,
  author =       "Vojt{\u{a}}ch Forejt and Saurabh Joshi and Daniel
                 Kroening and Ganesh Narayanaswamy and Subodh Sharma",
  title =        "Precise Predictive Analysis for Discovering
                 Communication Deadlocks in {MPI} Programs",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "4",
  pages =        "15:1--15:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3095075",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 19 06:38:32 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "The Message Passing Interface (MPI) is the standard
                 API for parallelization in high-performance and
                 scientific computing. Communication deadlocks are a
                 frequent problem in MPI programs, and this article
                 addresses the problem of discovering such deadlocks. We
                 begin by showing that if an MPI program is single path,
                 the problem of discovering communication deadlocks is
                 NP-complete. We then present a novel propositional
                 encoding scheme that captures the existence of
                 communication deadlocks. The encoding is based on
                 modeling executions with partial orders and implemented
                 in a tool called MOPPER. The tool executes an MPI
                 program, collects the trace, builds a formula from the
                 trace using the propositional encoding scheme, and
                 checks its satisfiability. Finally, we present
                 experimental results that quantify the benefit of the
                 approach in comparison to other analyzers and
                 demonstrate that it offers a scalable solution for
                 single-path programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lee:2017:SNS,
  author =       "Woosuk Lee and Wonchan Lee and Dongok Kang and Kihong
                 Heo and Hakjoo Oh and Kwangkeun Yi",
  title =        "Sound Non-Statistical Clustering of Static Analysis
                 Alarms",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "4",
  pages =        "16:1--16:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3095021",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 19 06:38:32 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a sound method for clustering alarms from
                 static analyzers. Our method clusters alarms by
                 discovering sound dependencies between them such that
                 if the dominant alarms of a cluster turns out to be
                 false, all the other alarms in the same cluster are
                 guaranteed to be false. We have implemented our
                 clustering algorithm on top of a realistic
                 buffer-overflow analyzer and proved that our method
                 reduces 45\% of alarm reports. Our framework is
                 applicable to any abstract interpretation-based static
                 analysis and orthogonal to abstraction refinements and
                 statistical ranking schemes.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Trinder:2017:SRI,
  author =       "Phil Trinder and Natalia Chechina and Nikolaos
                 Papaspyrou and Konstantinos Sagonas and Simon Thompson
                 and Stephen Adams and Stavros Aronis and Robert Baker
                 and Eva Bihari and Olivier Boudeville and Francesco
                 Cesarini and Maurizio {Di Stefano} and Sverker Eriksson
                 and Vikt{\'o}ria F{\"o}rd{\H{o}}s and Amir Ghaffari and
                 Aggelos Giantsios and Rickard Green and Csaba Hoch and
                 David Klaftenegger and Huiqing Li and Kenneth Lundin
                 and Kenneth Mackenzie and Katerina Roukounaki and
                 Yiannis Tsiouris and Kjell Winblad",
  title =        "Scaling Reliably: Improving the Scalability of the
                 {Erlang} Distributed Actor Platform",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "4",
  pages =        "17:1--17:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3107937",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 19 06:38:32 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Distributed actor languages are an effective means of
                 constructing scalable reliable systems, and the Erlang
                 programming language has a well-established and
                 influential model. While the Erlang model conceptually
                 provides reliable scalability, it has some inherent
                 scalability limits and these force developers to depart
                 from the model at scale. This article establishes the
                 scalability limits of Erlang systems and reports the
                 work of the EU RELEASE project to improve the
                 scalability and understandability of the Erlang
                 reliable distributed actor model. We systematically
                 study the scalability limits of Erlang and then address
                 the issues at the virtual machine, language, and tool
                 levels. More specifically: (1) We have evolved the
                 Erlang virtual machine so that it can work effectively
                 in large-scale single-host multicore and NUMA
                 architectures. We have made important changes and
                 architectural improvements to the widely used
                 Erlang/OTP release. (2) We have designed and
                 implemented Scalable Distributed (SD) Erlang libraries
                 to address language-level scalability issues and
                 provided and validated a set of semantics for the new
                 language constructs. (3) To make large Erlang systems
                 easier to deploy, monitor, and debug, we have developed
                 and made open source releases of five complementary
                 tools, some specific to SD Erlang. Throughout the
                 article we use two case studies to investigate the
                 capabilities of our new technologies and tools: a
                 distributed hash table based Orbit calculation and Ant
                 Colony Optimisation (ACO). Chaos Monkey experiments
                 show that two versions of ACO survive random process
                 failure and hence that SD Erlang preserves the Erlang
                 reliability model. While we report measurements on a
                 range of NUMA and cluster architectures, the key
                 scalability experiments are conducted on the Athos
                 cluster with 256 hosts (6,144 cores). Even for programs
                 with no global recovery data to maintain, SD Erlang
                 partitions the network to reduce network traffic and
                 hence improves performance of the Orbit and ACO
                 benchmarks above 80 hosts. ACO measurements show that
                 maintaining global recovery data dramatically limits
                 scalability; however, scalability is recovered by
                 partitioning the recovery data. We exceed the
                 established scalability limits of distributed Erlang,
                 and do not reach the limits of SD Erlang for these
                 benchmarks at this scale (256 hosts, 6,144 cores).",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Zhang:2017:SSH,
  author =       "Danfeng Zhang and Andrew C. Myers and Dimitrios
                 Vytiniotis and Simon Peyton-Jones",
  title =        "{SHErrLoc}: a Static Holistic Error Locator",
  journal =      j-TOPLAS,
  volume =       "39",
  number =       "4",
  pages =        "18:1--18:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3121137",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 19 06:38:32 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toplas/;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We introduce a general way to locate programmer
                 mistakes that are detected by static analyses. The
                 program analysis is expressed in a general constraint
                 language that is powerful enough to model type
                 checking, information flow analysis, dataflow analysis,
                 and points-to analysis. Mistakes in program analysis
                 result in unsatisfiable constraints. Given an
                 unsatisfiable system of constraints, both satisfiable
                 and unsatisfiable constraints are analyzed to identify
                 the program expressions most likely to be the cause of
                 unsatisfiability. The likelihood of different error
                 explanations is evaluated under the assumption that the
                 programmer's code is mostly correct, so the simplest
                 explanations are chosen, following Bayesian principles.
                 For analyses that rely on programmer-stated
                 assumptions, the diagnosis also identifies assumptions
                 likely to have been omitted. The new error diagnosis
                 approach has been implemented as a tool called
                 SHErrLoc, which is applied to three very different
                 program analyses, such as type inference for a highly
                 expressive type system implemented by the Glasgow
                 Haskell Compiler --- including type classes,
                 Generalized Algebraic Data Types (GADTs), and type
                 families. The effectiveness of the approach is
                 evaluated using previously collected programs
                 containing errors. The results show that when compared
                 to existing compilers and other tools, SHErrLoc
                 consistently identifies the location of programmer
                 errors significantly more accurately, without any
                 language-specific heuristics.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chen:2018:BPP,
  author =       "Hong-Yi Chen and Cristina David and Daniel Kroening
                 and Peter Schrammel and Bj{\"o}rn Wachter",
  title =        "Bit-Precise Procedure-Modular Termination Analysis",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "1",
  pages =        "1:1--1:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3121136",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 20 09:44:22 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Non-termination is the root cause of a variety of
                 program bugs, such as hanging programs and
                 denial-of-service vulnerabilities. This makes an
                 automated analysis that can prove the absence of such
                 bugs highly desirable. To scale termination checks to
                 large systems, an interprocedural termination analysis
                 seems essential. This is a largely unexplored area of
                 research in termination analysis, where most effort has
                 focussed on small but difficult single-procedure
                 problems. We present a modular termination analysis for
                 C programs using template-based interprocedural
                 summarisation. Our analysis combines a
                 context-sensitive, over-approximating forward analysis
                 with the inference of under-approximating preconditions
                 for termination. Bit-precise termination arguments are
                 synthesised over lexicographic linear ranking function
                 templates. Our experimental results show the advantage
                 of interprocedural reasoning over monolithic analysis
                 in terms of efficiency, while retaining comparable
                 precision.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Steimann:2018:CBR,
  author =       "Friedrich Steimann",
  title =        "Constraint-Based Refactoring",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3156016",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 20 09:44:22 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Constraint-based refactoring generalizes
                 constraint-based type refactoring as introduced by Tip
                 et al. [61] by extending the coverage of change from
                 types to names, locations, accessibilities, and other
                 properties of program elements. Starting with a generic
                 specification of refactoring tools, we systematically
                 develop constraint-based refactoring as a generic
                 solution to a certain class of refactoring problems and
                 provide a condition under which constraint-based
                 refactoring tools are proven correct for any given
                 target language. Although compliance with this
                 correctness condition is hard to prove for target
                 languages whose semantics is not formally defined, we
                 show how the condition gives rise to automated testing
                 procedures. We present a novel algorithm based on
                 constraint-logic programming for the generation of
                 constraints from a program to be refactored, and
                 demonstrate its time and space requirements by using it
                 in the application of refactorings to open source
                 programs. Summarizing earlier work, we show how the
                 principles underlying constraint-based refactoring
                 tools extend to ad hoc refactoring, cross-language
                 refactoring, and model/code co-refactoring.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lidman:2018:VRP,
  author =       "Jacob Lidman and Sally A. Mckee",
  title =        "Verifying Reliability Properties Using the Hyperball
                 Abstract Domain",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3156017",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 20 09:44:22 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Modern systems are increasingly susceptible to soft
                 errors that manifest themselves as bit flips and
                 possibly alter the semantics of an application. We
                 would like to measure the quality degradation on
                 semantics due to such bit flips, and thus we introduce
                 a Hyperball abstract domain that allows us to determine
                 the worst-case distance between expected and actual
                 results. Similar to intervals, hyperballs describe a
                 connected and dense space. The semantics of low-level
                 code in the presence of bit flips is hard to accurately
                 describe in such a space. We therefore combine the
                 Hyperball domain with an existing affine system
                 abstract domain that we extend to handle bit flips,
                 which are introduce as disjunctions. Bit-flips can
                 reduce the precision of our analysis, and we therefor
                 introduce the Scale domain as a disjunctive refinement
                 to minimize precision loss. This domain bounds the
                 number of disjunctive elements by quantifying the
                 over-approximation of different partitions and uses
                 submodular optimization to find a good partitioning
                 (within a bound of optimal). We evaluate these domains
                 to show benefits and potential problems. For the
                 application we examine here, adding the Scale domain to
                 the Hyperball abstraction improves accuracy by up to
                 two orders of magnitude. Our initial results
                 demonstrate the feasibility of this approach, although
                 we would like to further improve execution
                 efficiency.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Olmedo:2018:CPP,
  author =       "Federico Olmedo and Friedrich Gretz and Nils Jansen
                 and Benjamin Lucien Kaminski and Joost-Pieter Katoen
                 and Annabelle Mciver",
  title =        "Conditioning in Probabilistic Programming",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3156018",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 20 09:44:22 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "This article investigates the semantic intricacies of
                 conditioning, a main feature in probabilistic
                 programming. Our study is based on an extension of the
                 imperative probabilistic guarded command language pGCL
                 with conditioning. We provide a weakest precondition
                 (wp) semantics and an operational semantics. To deal
                 with possibly diverging program behavior, we consider
                 liberal preconditions. We show that diverging program
                 behavior plays a key role when defining conditioning.
                 We establish that weakest preconditions coincide with
                 conditional expected rewards in Markov chains-the
                 operational semantics-and that the wp-semantics
                 conservatively extends the existing semantics of pGCL
                 (without conditioning). An extension of these results
                 with nondeterminism turns out to be problematic:
                 although an operational semantics using Markov decision
                 processes is rather straightforward, we show that
                 providing an inductive wp-semantics in this setting is
                 impossible. Finally, we present two program
                 transformations that eliminate conditioning from any
                 program. The first transformation hoists conditioning
                 while updating the probabilistic choices in the
                 program, while the second transformation replaces
                 conditioning-in the same vein as rejection sampling-by
                 a program with loops. In addition, we present a last
                 program transformation that replaces an independent
                 identically distributed loop with conditioning.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{David:2018:PSP,
  author =       "Cristina David and Pascal Kesseli and Daniel Kroening
                 and Matt Lewis",
  title =        "Program Synthesis for Program Analysis",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "2",
  pages =        "5:1--5:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3174802",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article, we propose a unified framework for
                 designing static analysers based on program synthesis.
                 For this purpose, we identify a fragment of
                 second-order logic with restricted quantification that
                 is expressive enough to model numerous static analysis
                 problems (e.g., safety proving, bug finding,
                 termination and non-termination proving, refactoring).
                 As our focus is on programs that use bit-vectors, we
                 build a decision procedure for this fragment over
                 finite domains in the form of a program synthesiser. We
                 provide instantiations of our framework for solving a
                 diverse range of program verification tasks such as
                 termination, non-termination, safety and bug finding,
                 superoptimisation, and refactoring. Our experimental
                 results show that our program synthesiser compares
                 positively with specialised tools in each area as well
                 as with general-purpose synthesisers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Banerjee:2018:LAF,
  author =       "Anindya Banerjee and David A. Naumann and Mohammad
                 Nikouei",
  title =        "A Logical Analysis of Framing for Specifications with
                 Pure Method Calls",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "2",
  pages =        "6:1--6:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3174801",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "For specifying and reasoning about object-based
                 programs, it is often attractive for contracts to be
                 expressed using calls to pure methods. It is useful for
                 pure methods to have contracts, including read effects,
                 to support local reasoning based on frame conditions.
                 This leads to puzzles such as the use of a pure method
                 in its own contract. These ideas have been explored in
                 connection with verification tools based on axiomatic
                 semantics, guided by the need to avoid logical
                 inconsistency, and focusing on encodings that cater for
                 first-order automated provers. This article adds pure
                 methods and read effects to region logic, a first-order
                 program logic that features frame-based local reasoning
                 and provides modular reasoning principles for
                 end-to-end correctness. Modular reasoning is embodied
                 in a proof rule for linking a module's method
                 implementations with a client that relies on the method
                 contracts. Soundness is proved with respect to
                 conventional operational semantics and uses an
                 extensional (i.e, relational) interpretation of read
                 effects. Applicability to tools based on SMT solvers is
                 demonstrated through machine-checked verification of
                 examples. The developments in this article can guide
                 the implementations of linking as used in modular
                 verifiers and serve as a basis for studying
                 observationally pure methods and encapsulation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chatterjee:2018:AAQ,
  author =       "Krishnendu Chatterjee and Hongfei Fu and Petr
                 Novotn{\'y} and Rouzbeh Hasheminezhad",
  title =        "Algorithmic Analysis of Qualitative and Quantitative
                 Termination Problems for Affine Probabilistic
                 Programs",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3174800",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In this article, we consider the termination problem
                 of probabilistic programs with real-valued variables.
                 The questions concerned are: qualitative ones that ask
                 (i) whether the program terminates with probability 1
                 (almost-sure termination) and (ii) whether the expected
                 termination time is finite (finite termination); and
                 quantitative ones that ask (i) to approximate the
                 expected termination time (expectation problem) and
                 (ii) to compute a bound B such that the probability not
                 to terminate after B steps decreases exponentially
                 (concentration problem). To solve these questions, we
                 utilize the notion of ranking supermartingales, which
                 is a powerful approach for proving termination of
                 probabilistic programs. In detail, we focus on
                 algorithmic synthesis of linear
                 ranking-supermartingales over affine probabilistic
                 programs (A pps) with both angelic and demonic
                 non-determinism. An important subclass of Apps is LRApp
                 which is defined as the class of all Apps over which a
                 linear ranking-supermartingale exists. Our main
                 contributions are as follows. Firstly, we show that the
                 membership problem of LRA pp (i) can be decided in
                 polynomial time for Apps with at most demonic
                 non-determinism, and (ii) is NP-hard and in PSPACE for
                 Apps with angelic non-determinism. Moreover, the
                 NP-hardness result holds already for Apps without
                 probability and demonic non-determinism. Secondly, we
                 show that the concentration problem over LRApp can be
                 solved in the same complexity as for the membership
                 problem of LRApp. Finally, we show that the expectation
                 problem over LRApp can be solved in 2EXPTIME and is
                 PSPACE-hard even for Apps without probability and
                 non-determinism (i.e., deterministic programs). Our
                 experimental results demonstrate the effectiveness of
                 our approach to answer the qualitative and quantitative
                 questions over Apps with at most demonic
                 non-determinism.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grimmer:2018:CLI,
  author =       "Matthias Grimmer and Roland Schatz and Chris Seaton
                 and Thomas W{\"u}rthinger and Mikel Luj{\'a}n",
  title =        "Cross-Language Interoperability in a Multi-Language
                 Runtime",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jun,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3201898",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "In large-scale software applications, programmers
                 often combine different programming languages because
                 this allows them to use the most suitable language for
                 a given problem, to gradually migrate existing projects
                 from one language to another, or to reuse existing
                 source code. However, different programming languages
                 have fundamentally different implementations, which are
                 hard to combine. The composition of language
                 implementations often results in complex interfaces
                 between languages, insufficient flexibility, or poor
                 performance. We propose TruffleVM, a virtual machine
                 (VM) that can execute different programming languages
                 and is able to compose them in a seamless way.
                 TruffleVM supports dynamically-typed languages (e.g.,
                 JavaScript and Ruby) as well as statically typed
                 low-level languages (e.g., C). It consists of
                 individual language implementations, which translate
                 source code to an intermediate representation that is
                 executed by a shared VM. TruffleVM composes these
                 different language implementations via generic access.
                 Generic access is a language-agnostic mechanism that
                 language implementations use to access foreign data or
                 call foreign functions. It features language-agnostic
                 messages that the TruffleVM resolves to efficient
                 foreign-language-specific operations at runtime.
                 Generic access supports multiple languages, enables an
                 efficient multi-language development, and ensures high
                 performance. We evaluate generic access with two case
                 studies. The first one explains the transparent
                 composition of JavaScript, Ruby, and C. The second one
                 shows an implementation of the C extensions application
                 programming interface (API) for Ruby. We show that
                 generic access guarantees good runtime performance. It
                 avoids conversion or marshalling of foreign objects at
                 the language boundary and allows the dynamic compiler
                 to perform its optimizations across language
                 boundaries.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chatterjee:2018:AAP,
  author =       "Krishnendu Chatterjee and Rasmus Ibsen-Jensen and Amir
                 Kafshdar Goharshady and Andreas Pavlogiannis",
  title =        "Algorithms for Algebraic Path Properties in Concurrent
                 Systems of Constant Treewidth Components",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "9:1--9:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3210257",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We study algorithmic questions wrt algebraic path
                 properties in concurrent systems, where the transitions
                 of the system are labeled from a complete, closed
                 semiring. The algebraic path properties can model
                 dataflow analysis problems, the shortest path problem,
                 and many other natural problems that arise in program
                 analysis. We consider that each component of the
                 concurrent system is a graph with constant treewidth, a
                 property satisfied by the controlflow graphs of most
                 programs. We allow for multiple possible queries, which
                 arise naturally in demand driven dataflow analysis. The
                 study of multiple queries allows us to consider the
                 tradeoff between the resource usage of the one-time
                 preprocessing and for each individual query. The
                 traditional approach constructs the product graph of
                 all components and applies the best-known graph
                 algorithm on the product. In this approach, even the
                 answer to a single query requires the transitive
                 closure (i.e., the results of all possible queries),
                 which provides no room for tradeoff between
                 preprocessing and query time. Our main contributions
                 are algorithms that significantly improve the
                 worst-case running time of the traditional approach,
                 and provide various tradeoffs depending on the number
                 of queries. For example, in a concurrent system of two
                 components, the traditional approach requires hexic
                 time in the worst case for answering one query as well
                 as computing the transitive closure, whereas we show
                 that with one-time preprocessing in almost cubic time,
                 each subsequent query can be answered in at most linear
                 time, and even the transitive closure can be computed
                 in almost quartic time. Furthermore, we establish
                 conditional optimality results showing that the
                 worst-case running time of our algorithms cannot be
                 improved without achieving major breakthroughs in graph
                 algorithms (i.e., improving the worst-case bound for
                 the shortest path problem in general graphs).
                 Preliminary experimental results show that our
                 algorithms perform favorably on several benchmarks.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Florence:2018:PPP,
  author =       "Spencer P. Florence and Burke Fetscher and Matthew
                 Flatt and William H. Temps and Vincent St-Amour and
                 Tina Kiguradze and Dennis P. West and Charlotte Niznik
                 and Paul R. Yarnold and Robert Bruce Findler and Steven
                 M. Belknap",
  title =        "{POP-PL}: a Patient-Oriented Prescription Programming
                 Language",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "10:1--10:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3210256",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "A medical prescription is a set of health care
                 instructions that govern the plan of care for an
                 individual patient, which may include orders for drug
                 therapy, diet, clinical assessment, and laboratory
                 testing. Clinicians have long used algorithmic thinking
                 to describe and implement prescriptions but without the
                 benefit of a formal programming language. Instead,
                 medical algorithms are expressed using a natural
                 language patois, flowcharts, or as structured data in
                 an electronic medical record system. The lack of a
                 prescription programming language inhibits
                 expressiveness; results in prescriptions that are
                 difficult to understand, hard to debug, and awkward to
                 reuse; and increases the risk of fatal medical error.
                 This article reports on the design and evaluation of
                 Patient-Oriented Prescription Programming Language
                 (POP-PL), a domain-specific programming language
                 designed for expressing prescriptions. The language is
                 based around the idea that programs and humans have
                 complementary strengths that, when combined properly,
                 can make for safer, more accurate performance of
                 prescriptions. Use of POP-PL facilitates automation of
                 certain low-level vigilance tasks, freeing up human
                 cognition for abstract thinking, compassion, and human
                 communication. We implemented this language and
                 evaluated its design attempting to write prescriptions
                 in the new language and evaluated its usability by
                 assessing whether clinicians can understand and modify
                 prescriptions written in the language. We found that
                 some medical prescriptions can be expressed in a formal
                 domain-specific programming language, and we determined
                 that medical professionals can understand and correctly
                 modify programs written in POP-PL. We also discuss
                 opportunities for refining and further developing
                 POP-PL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Danicic:2018:SBS,
  author =       "Sebastian Danicic and Michael R. Laurence",
  title =        "Static Backward Slicing of Non-deterministic Programs
                 and Systems",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "11:1--11:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/2886098",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See {Editor}'s foreword \cite{Myers:2018:EFS}.",
  abstract =     "A theory of slicing non-deterministic programs and
                 systems is developed. Non-deterministic programs and
                 systems are represented as non-deterministic program
                 graphs (NDPGs) that allow arbitrary non-deterministic
                 branching to be expressed. Structural and semantic
                 relationships that must exist between an NDPG and (1)
                 its non-termination insensitive (weak) slices and (2)
                 its non-termination sensitive (strong) slices are
                 defined. Weak and strong commitment closure are
                 introduced. These are the NDPG equivalents of being
                 closed under non-termination sensitive and
                 non-termination insensitive control dependence;
                 properties defined on subsets of vertices of the
                 equivalent deterministic structure: the control flow
                 graph. It is proved that if a subset of the vertices of
                 an NDPG is both data dependence closed and
                 (weak/strong) commitment closed, then the resulting
                 induced graph will, indeed, satisfy our structural and
                 semantic requirements. O ( n$^3$ ) algorithms for
                 computing minimal data and weak/strong commitment
                 closed sets are given. The resulting induced graphs are
                 thus guaranteed to be weak and strong slices,
                 respectively. It is demonstrated, with examples, that
                 programs written in Dijkstra's non-deterministic
                 guarded command language (DNGCL) can be converted to
                 NDPGs to which our slicing algorithms can then be
                 applied. It is proved that the resulting slices (NDPGs)
                 can always be converted back to valid DNGCL programs,
                 highlighting the applicability of our approach to
                 slicing at the source code level.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Myers:2018:EFS,
  author =       "Andrew Myers",
  title =        "{Editor}'s Foreword to {``Static Backward Slicing of
                 Non-Deterministic Programs and Systems''}",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "11:1--11:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3243871",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Danicic:2018:SBS}.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11e",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jacobs:2018:MTV,
  author =       "Bart Jacobs and Dragan Bosnacki and Ruurd Kuiper",
  title =        "Modular Termination Verification of Single-Threaded
                 and Multithreaded Programs",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "12:1--12:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3210258",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We propose an approach for the modular specification
                 and verification of total correctness properties of
                 object-oriented programs. The core of our approach is a
                 specification style that prescribes a way to assign a
                 level expression to each method such that each callee's
                 level is below the caller's, even in the presence of
                 dynamic binding. The specification style yields
                 specifications that properly hide implementation
                 details. The main idea is to use multisets of method
                 names as levels, and to associate with each object
                 levels that abstractly reflect the way the object is
                 built from other objects. A method's level is then
                 defined in terms of the method's own name and the
                 levels associated with the objects passed as arguments.
                 We first present the specification style in the context
                 of programs that do not modify object fields. We then
                 combine it with separation logic and abstract predicate
                 families to obtain an approach for programs with heap
                 mutation. In a third step, we address concurrency, by
                 incorporating an existing approach for verifying
                 deadlock freedom of channels and locks. Our main
                 contribution here is to achieve information hiding by
                 using the proposed termination levels for lock ordering
                 as well. Also, we introduce call permissions to enable
                 elegant verification of termination of programs where
                 threads cause work in other threads, such as in thread
                 pools or fine-grained concurrent algorithms involving
                 compare-and-swap loops. We explain how our approach can
                 be used also to verify the liveness of nonterminating
                 programs.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kim:2018:TFS,
  author =       "Se-Won Kim and Xavier Rival and Sukyoung Ryu",
  title =        "A Theoretical Foundation of Sensitivity in an Abstract
                 Interpretation Framework",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "3",
  pages =        "13:1--13:??",
  month =        aug,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3230624",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Oct 18 12:01:50 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Program analyses often utilize various forms of
                 sensitivity such as context sensitivity, call-site
                 sensitivity, and object sensitivity. These techniques
                 all allow for more precise program analyses, that are
                 able to compute more precise program invariants, and to
                 verify stronger properties. Despite the fact that
                 sensitivity techniques are now part of the standard
                 toolkit of static analyses designers and implementers,
                 no comprehensive frameworks allow the description of
                 all common forms of sensitivity. As a consequence, the
                 soundness proofs of static analysis tools involving
                 sensitivity often rely on ad hoc formalization, which
                 are not always carried out in an abstract
                 interpretation framework. Moreover, this also means
                 that opportunities to identify similarities between
                 analysis techniques to better improve abstractions or
                 to tune static analysis tools can easily be missed. In
                 this article, we present and formalize a framework for
                 the description of sensitivity in static analysis. Our
                 framework is based on a powerful abstract domain
                 construction, and utilizes reduced cardinal power to
                 tie basic abstract predicates to the properties
                 analyses are sensitive to. We formalize this
                 abstraction, and the main abstract operations that are
                 needed to turn it into a generic abstract domain
                 construction. We demonstrate that our approach can
                 allow for a more precise description of program states,
                 and that it can also describe a large set of
                 sensitivity techniques, both when sensitivity criteria
                 are static (known before the analysis) or dynamic
                 (inferred as part of the analysis), and sensitive
                 analysis tuning parameters. Last, we show that
                 sensitivity techniques used in state-of-the-art static
                 analysis tools can be described in our framework.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Heo:2018:ASA,
  author =       "Kihong Heo and Hakjoo Oh and Hongseok Yang and
                 Kwangkeun Yi",
  title =        "Adaptive Static Analysis via Learning with {Bayesian}
                 Optimization",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "4",
  pages =        "14:1--14:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3121135",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3121135",
  abstract =     "Building a cost-effective static analyzer for
                 real-world programs is still regarded an art. One key
                 contributor to this grim reputation is the difficulty
                 in balancing the cost and the precision of an analyzer.
                 An ideal analyzer should be adaptive to a given
                 analysis task and avoid using techniques that
                 unnecessarily improve precision and increase analysis
                 cost. However, achieving this ideal is highly
                 nontrivial, and it requires a large amount of
                 engineering efforts. In this article, we present a new
                 learning-based approach for adaptive static analysis.
                 In our approach, the analysis includes a sophisticated
                 parameterized strategy that decides, for each part of a
                 given program, whether to apply a precision-improving
                 technique to that part or not. We present a method for
                 learning a good parameter for such a strategy from an
                 existing codebase via Bayesian optimization. The learnt
                 strategy is then used for new, unseen programs. Using
                 our approach, we developed partially flow- and
                 context-sensitive variants of a realistic C static
                 analyzer. The experimental results demonstrate that
                 using Bayesian optimization is crucial for learning
                 from an existing codebase. Also, they show that among
                 all program queries that require flow- or
                 context-sensitivity, our partially flow- and
                 context-sensitive analysis answers 75\% of them, while
                 increasing the analysis cost only by 3.3$ \times $ of
                 the baseline flow- and context-insensitive analysis,
                 rather than 40$ \times $ or more of the fully sensitive
                 version.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ugawa:2018:TSL,
  author =       "Tomoharu Ugawa and Carl G. Ritson and Richard E.
                 Jones",
  title =        "Transactional {Sapphire}: Lessons in High-Performance,
                 On-the-fly Garbage Collection",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "4",
  pages =        "15:1--15:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3226225",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Constructing a high-performance garbage collector is
                 hard. Constructing a fully concurrent `on-the-fly'
                 compacting collector is much more so. We describe our
                 experience of implementing the Sapphire algorithm as
                 the first on-the-fly, parallel, replication copying,
                 garbage collector for the Jikes RVM Java virtual
                 machine (JVM). In part, we explain our innovations such
                 as copying with hardware and software transactions,
                 on-the-fly management of Java's reference types, and
                 simple, yet correct, lock-free management of volatile
                 fields in a replicating collector. We fully evaluate,
                 for the first time, and using realistic benchmarks,
                 Sapphire's performance and suitability as a low latency
                 collector. An important contribution of this work is a
                 detailed description of our experience of building an
                 on-the-fly copying collector for a complete JVM with
                 some assurance that it is correct. A key aspect of this
                 is model checking of critical components of this
                 complicated and highly concurrent system.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Toro:2018:TDG,
  author =       "Mat{\'\i}as Toro and Ronald Garcia and {\'E}ric
                 Tanter",
  title =        "Type-Driven Gradual Security with References",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "4",
  pages =        "16:1--16:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3229061",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See corrigendum \cite{Toro:2020:CTD}.",
  abstract =     "In security-typed programming languages, types
                 statically enforce noninterference between potentially
                 conspiring values, such as the arguments and results of
                 functions. But to adopt static security types, like
                 other advanced type disciplines, programmers face a
                 steep wholesale transition, often forcing them to
                 refactor working code just to satisfy their type
                 checker. To provide a gentler path to security typing
                 that supports safe and stylish but hard-to-verify
                 programming idioms, researchers have designed languages
                 that blend static and dynamic checking of security
                 types. Unfortunately, most of the resulting languages
                 only support static, type-based reasoning about
                 noninterference if a program is entirely statically
                 secured. This limitation substantially weakens the
                 benefits that dynamic enforcement brings to static
                 security typing. Additionally, current proposals are
                 focused on languages with explicit casts and therefore
                 do not fulfill the vision of gradual typing, according
                 to which the boundaries between static and dynamic
                 checking only arise from the (im)precision of type
                 annotations and are transparently mediated by implicit
                 checks. In this article, we present GSL$_{Ref}$, a
                 gradual security-typed higher-order language with
                 references. As a gradual language, GSL$_{Ref}$ supports
                 the range of static-to-dynamic security checking
                 exclusively driven by type annotations, without
                 resorting to explicit casts. Additionally, GSL$_{Ref}$
                 lets programmers use types to reason statically about
                 termination-insensitive noninterference in all
                 programs, even those that enforce security dynamically.
                 We prove that GSL$_{Ref}$ satisfies all but one of Siek
                 et al.'s criteria for gradually-typed languages, which
                 ensure that programs can seamlessly transition between
                 simple typing and security typing. A notable exception
                 regards the dynamic gradual guarantee, which some
                 specific programs must violate if they are to satisfy
                 noninterference; it remains an open question whether
                 such a language could fully satisfy the dynamic gradual
                 guarantee. To realize this design, we were led to draw
                 a sharp distinction between syntactic type safety and
                 semantic type soundness, each of which constrains the
                 design of the gradual language.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Toninho:2018:ISB,
  author =       "Bernardo Toninho and Nobuko Yoshida",
  title =        "Interconnectability of Session-Based Logical
                 Processes",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "4",
  pages =        "17:1--17:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3242173",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "In multiparty session types, interconnection networks
                 identify which roles in a session engage in
                 communication (i.e., two roles are connected if they
                 exchange a message). In session-based interpretations
                 of linear logic the analogue notion corresponds to
                 determining which processes are composed, or cut, using
                 compatible channels typed by linear propositions. In
                 this work, we show that well-formed interactions
                 represented in a session-based interpretation of
                 classical linear logic (CLL) form strictly
                 less-expressive interconnection networks than those of
                 a multiparty session calculus. To achieve this result,
                 we introduce a new compositional synthesis property
                 dubbed partial multiparty compatibility (PMC), enabling
                 us to build a global type denoting the interactions
                 obtained by iterated composition of well-typed CLL
                 threads. We then show that CLL composition induces PMC
                 global types without circular interconnections between
                 three (or more) participants. PMC is then used to
                 define a new CLL composition rule that can form
                 circular interconnections but preserves the
                 deadlock-freedom of CLL.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Anonymous:2018:CCL,
  author =       "Anonymous",
  title =        "Corrigendum to {``Cross-Language Interoperability in a
                 Multi-Language Runtime'', by Grimmer et al., ACM
                 Transactions on Programming Languages and Systems
                 (TOPLAS) Volume 40, Issue 2, Article No. 8}",
  journal =      j-TOPLAS,
  volume =       "40",
  number =       "4",
  pages =        "18:1--18:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3283723",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3283723",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cogumbreiro:2019:DDV,
  author =       "Tiago Cogumbreiro and Raymond Hu and Francisco Martins
                 and Nobuko Yoshida",
  title =        "Dynamic Deadlock Verification for General Barrier
                 Synchronisation",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "1:1--1:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3229060",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3229060",
  abstract =     "We present Armus, a verification tool for dynamically
                 detecting or avoiding barrier deadlocks. The core
                 design of Armus is based on phasers, a generalisation
                 of barriers that supports split-phase synchronisation,
                 dynamic membership, and optional-waits. This allows
                 Armus to handle the key barrier synchronisation
                 patterns found in modern languages and libraries. We
                 implement Armus for X10 and Java, giving the first
                 sound and complete barrier deadlock verification tools
                 in these settings. Armus introduces a novel event-based
                 graph model of barrier concurrency constraints that
                 distinguishes task-event and event-task dependencies.
                 Decoupling these two kinds of dependencies facilitates
                 the verification of distributed barriers with dynamic
                 membership, a challenging feature of X10. Further, our
                 base graph representation can be dynamically switched
                 between a task-to-task model, Wait-for Graph (WFG), and
                 an event-to-event model, State Graph (SG), to improve
                 the scalability of the analysis. Formally, we show that
                 the verification is sound and complete with respect to
                 the occurrence of deadlock in our core phaser language,
                 and that switching graph representations preserves the
                 soundness and completeness properties. These results
                 are machine checked with the Coq proof assistant.
                 Practically, we evaluate the runtime overhead of our
                 implementations using three benchmark suites in local
                 and distributed scenarios. Regarding deadlock
                 detection, distributed scenarios show negligible
                 overheads and local scenarios show overheads below
                 1.15$ \times $. Deadlock avoidance is more demanding,
                 and highlights the potential gains from dynamic graph
                 selection. In one benchmark scenario, the runtime
                 overheads vary from 1.8$ \times $ for dynamic
                 selection, 2.6$ \times $ for SG-static selection, and
                 5.9$ \times $ for WFG-static selection.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Solovyev:2019:REF,
  author =       "Alexey Solovyev and Marek S. Baranowski and Ian Briggs
                 and Charles Jacobsen and Zvonimir Rakamari{\'c} and
                 Ganesh Gopalakrishnan",
  title =        "Rigorous Estimation of Floating-Point Round-Off Errors
                 with Symbolic {Taylor} Expansions",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "2:1--2:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3230733",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3230733",
  abstract =     "Rigorous estimation of maximum floating-point
                 round-off errors is an important capability central to
                 many formal verification tools. Unfortunately,
                 available techniques for this task often provide very
                 pessimistic overestimates, causing unnecessary
                 verification failure. We have developed a new approach
                 called Symbolic Taylor Expansions that avoids these
                 problems, and implemented a new tool called FPTaylor
                 embodying this approach. Key to our approach is the use
                 of rigorous global optimization, instead of the more
                 familiar interval arithmetic, affine arithmetic, and/or
                 SMT solvers. FPTaylor emits per-instance analysis
                 certificates in the form of HOL Light proofs that can
                 be machine checked. In this article, we present the
                 basic ideas behind Symbolic Taylor Expansions in
                 detail. We also survey as well as thoroughly evaluate
                 six tool families, namely, Gappa (two tool options
                 studied), Fluctuat, PRECiSA, Real2Float, Rosa, and
                 FPTaylor (two tool options studied) on 24 examples,
                 running on the same machine, and taking care to find
                 the best options for running each of these tools. This
                 study demonstrates that FPTaylor estimates round-off
                 errors within much tighter bounds compared to other
                 tools on a significant number of case studies. We also
                 release FPTaylor along with our benchmarks, thus
                 contributing to future studies and tool development in
                 this area.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jacek:2019:OCW,
  author =       "Nicholas Jacek and Meng-Chieh Chiu and Benjamin M.
                 Marlin and J. Eliot B. Moss",
  title =        "Optimal Choice of When to Garbage Collect",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "3:1--3:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3282438",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We consider the ultimate limits of program-specific
                 garbage collector (GC) performance for real programs.
                 We first characterize the GC schedule optimization
                 problem. Based on this characterization, we develop a
                 linear-time dynamic programming solution that, given a
                 program run and heap size, computes an optimal schedule
                 of collections for a non-generational collector. Using
                 an analysis of a heap object graph of the program, we
                 compute a property of heap objects that we call their
                 pre-birth time. This information enables us to extend
                 the non-generational GC schedule problem to the
                 generational GC case in a way that also admits a
                 dynamic programming solution with cost quadratic in the
                 length of the trace (number of objects allocated). This
                 improves our previously reported approximately optimal
                 result. We further extend the two-generation dynamic
                 program to any number of generations, allowing other
                 generalizations as well. Our experimental results for
                 two generations on traces from Java programs of the
                 DaCapo benchmark suite show that there is considerable
                 promise to reduce garbage collection costs for some
                 programs by developing program-specific collection
                 policies. For a given space budget, optimal schedules
                 often obtain modest but useful time savings, and for a
                 given time budget, optimal schedules can obtain
                 considerable space savings.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Andersen:2019:FSP,
  author =       "Leif Andersen and Vincent St-Amour and Jan Vitek and
                 Matthias Felleisen",
  title =        "Feature-Specific Profiling",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "4:1--4:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3275519",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3275519",
  abstract =     "While high-level languages come with significant
                 readability and maintainability benefits, their
                 performance remains difficult to predict. For example,
                 programmers may unknowingly use language features
                 inappropriately, which cause their programs to run
                 slower than expected. To address this issue, we
                 introduce feature-specific profiling, a technique that
                 reports performance costs in terms of linguistic
                 constructs. Feature-specific profilers help programmers
                 find expensive uses of specific features of their
                 language. We describe the architecture of a profiler
                 that implements our approach, explain prototypes of the
                 profiler for two languages with different
                 characteristics and implementation strategies, and
                 provide empirical evidence for the approach's general
                 usefulness as a performance debugging tool.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lepigre:2019:PSC,
  author =       "Rodolphe Lepigre and Christophe Raffalli",
  title =        "Practical Subtyping for {Curry}-Style Languages",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "5:1--5:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3285955",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "We present a new, syntax-directed framework for
                 Curry-style type systems with subtyping. It supports a
                 rich set of features, and allows for a reasonably
                 simple theory and implementation. The system we
                 consider has sum and product types, universal and
                 existential quantifiers, and inductive and coinductive
                 types. The latter two may carry size invariants that
                 can be used to establish the termination of recursive
                 programs. For example, the termination of quicksort can
                 be derived by showing that partitioning a list does not
                 increase its size. The system deals with complex
                 programs involving mixed induction and coinduction, or
                 even mixed polymorphism and (co-)induction. One of the
                 key ideas is to separate the notion of size from
                 recursion. We do not check the termination of programs
                 directly, but rather show that their (circular) typing
                 proofs are well-founded. Termination is then obtained
                 using a standard (semantic) normalisation proof. To
                 demonstrate the practicality of the system, we provide
                 an implementation accepting all the examples discussed
                 in the article.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liu:2019:RIP,
  author =       "Bozhen Liu and Jeff Huang and Lawrence Rauchwerger",
  title =        "Rethinking Incremental and Parallel Pointer Analysis",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "1",
  pages =        "6:1--6:??",
  month =        mar,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3293606",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Mon Mar 4 08:35:09 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  abstract =     "Pointer analysis is at the heart of most
                 interprocedural program analyses. However, scaling
                 pointer analysis to large programs is extremely
                 challenging. In this article, we study incremental
                 pointer analysis and present a new algorithm for
                 computing the points-to information incrementally
                 (i.e., upon code insertion, deletion, and
                 modification). Underpinned by new observations of
                 incremental pointer analysis, our algorithm
                 significantly advances the state of the art in that it
                 avoids redundant computations and the expensive graph
                 reachability analysis, and preserves precision as the
                 corresponding whole program exhaustive analysis.
                 Moreover, it is parallel within each iteration of
                 fixed-point computation. We have implemented our
                 algorithm, IPA, for Java based on the WALA framework
                 and evaluated its performance extensively on real-world
                 large, complex applications. Experimental results show
                 that IPA achieves more than 200X speedups over existing
                 incremental algorithms, two to five orders of magnitude
                 faster than whole program pointer analysis, and also
                 improves the performance of an incremental data race
                 detector by orders of magnitude. Our IPA implementation
                 is open source and has been adopted by WALA.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Myers:2019:E,
  author =       "Andrew Myers",
  title =        "Editorial",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3324782",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3324782",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Miquey:2019:CSC,
  author =       "{\'E}tienne Miquey",
  title =        "A Classical Sequent Calculus with Dependent Types",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3230625",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3230625",
  abstract =     "Dependent types are a key feature of the proof
                 assistants based on the Curry--Howard isomorphism. It
                 is well known that this correspondence can be extended
                 to classical logic by enriching the language of proofs
                 with control operators. However, they are known to
                 misbehave in the presence of dependent types, unless
                 dependencies are restricted to values. Moreover, while
                 sequent calculi naturally support
                 continuation-passing-style interpretations, there is no
                 such presentation of a language with dependent types.
                 The main achievement of this article is to give a
                 sequent calculus presentation of a call-by-value
                 language with a control operator and dependent types,
                 and to justify its soundness through a
                 continuation-passing-style translation. We start from
                 the call-by-value version of the $ \lambda \mu \tilde
                 \mu $-calculus. We design a minimal language with a
                 value restriction and a type system that includes a
                 list of explicit dependencies to maintain type safety.
                 We then show how to relax the value restriction and
                 introduce delimited continuations to directly prove the
                 consistency by means of a continuation-passing-style
                 translation. Finally, we relate our calculus to a
                 similar system by Lepigre and present a methodology to
                 transfer properties from this system to our own.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Padovani:2019:CFS,
  author =       "Luca Padovani",
  title =        "Context-Free Session Type Inference",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "9:1--9:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3229062",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3229062",
  abstract =     "Some interesting communication protocols can be
                 precisely described only by context-free session types,
                 an extension of conventional session types supporting a
                 general form of sequential composition. The complex
                 metatheory of context-free session types, however,
                 hinders the definition of corresponding checking and
                 inference algorithms. In this work, we study a new
                 syntax-directed type system for context-free session
                 types that is easy to embed into a host programming
                 language. We also detail 2 OCaml embeddings that allow
                 us to piggyback on OCaml's type system to check and
                 infer context-free session types.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{DalLago:2019:PTM,
  author =       "Ugo {Dal Lago} and Charles Grellois",
  title =        "Probabilistic Termination by Monadic Affine Sized
                 Typing",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "10:1--10:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3293605",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3293605",
  abstract =     "We introduce a system of monadic affine sized types,
                 which substantially generalizes usual sized types and
                 allows in this way to capture probabilistic
                 higher-order programs that terminate almost surely.
                 Going beyond plain, strong normalization without losing
                 soundness turns out to be a hard task, which cannot be
                 accomplished without a richer, quantitative notion of
                 types, but also without imposing some affinity
                 constraints. The proposed type system is powerful
                 enough to type classic examples of probabilistically
                 terminating programs such as random walks. The way
                 typable programs are proved to be almost surely
                 terminating is based on reducibility but requires a
                 substantial adaptation of the technique.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Cotton-Barratt:2019:MVP,
  author =       "Conrad Cotton-Barratt and Andrzej S. Murawski and
                 C.-H. Luke Ong",
  title =        "{ML}, Visibly Pushdown Class Memory Automata, and
                 Extended Branching Vector Addition Systems with
                 States",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "11:1--11:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3310338",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3310338",
  abstract =     "We prove that the observational equivalence problem
                 for a finitary fragment of the programming langauge ML
                 is recursively equivalent to the reachability problem
                 for extended branching vector addition systems with
                 states (EBVASS). This result has two natural and
                 independent parts. We first prove that the
                 observational equivalence problem is equivalent to the
                 emptiness problem for a new class of class memory
                 automata equipped with a visibly pushdown stack, called
                 Visibly Pushdown Class Memory Automata (VPCMA). Our
                 proof uses the fully abstract game semantics of the
                 language. We then prove that the VPCMA emptiness
                 problem is equivalent to the reachability problem for
                 EBVASS. The results of this article complete our
                 programme to give an automata classification of the ML
                 types with respect to the observational equivalence
                 problem for closed terms.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Hague:2019:CMC,
  author =       "Matthew Hague and Anthony W. Lin and Chih-Duo Hong",
  title =        "{CSS} Minification via Constraint Solving",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "12:1--12:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3310337",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3310337",
  abstract =     "Minification is a widely accepted technique that aims
                 at reducing the size of the code transmitted over the
                 web. This article concerns the problem of
                 semantic-preserving minification of Cascading Style
                 Sheets (CSS)-the de facto language for styling web
                 documents-based on merging similar rules. The cascading
                 nature of CSS makes the semantics of CSS files
                 sensitive to the ordering of rules in the file. To
                 automatically identify rule-merging opportunities that
                 best minimise file size, we reduce the rule-merging
                 problem to a problem concerning ``CSS-graphs,'' i.e.,
                 node-weighted bipartite graphs with a dependency
                 ordering on the edges, where weights capture the number
                 of characters. Constraint solving plays a key role in
                 our approach. Transforming a CSS file into a CSS-graph
                 problem requires us to extract the dependency ordering
                 on the edges (an NP-hard problem), which requires us to
                 solve the selector intersection problem. To this end,
                 we provide the first full formalisation of CSS3
                 selectors (the most stable version of CSS) and reduce
                 their selector intersection problem to satisfiability
                 of quantifier-free integer linear arithmetic, for which
                 highly optimised SMT-solvers are available. To solve
                 the above NP-hard graph optimisation problem, we show
                 how Max-SAT solvers can be effectively employed. We
                 have implemented our rule-merging algorithm and tested
                 it against approximately 70 real-world examples
                 (including examples from each of the top 20 most
                 popular websites). We also used our benchmarks to
                 compare our tool against six well-known minifiers
                 (which implement other optimisations). Our experiments
                 suggest that our tool produced larger savings. A
                 substantially better minification rate was shown when
                 our tool is used together with these minifiers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Jeon:2019:MLA,
  author =       "Minseok Jeon and Sehun Jeong and Sungdeok Cha and
                 Hakjoo Oh",
  title =        "A Machine-Learning Algorithm with Disjunctive Model
                 for Data-Driven Program Analysis",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "2",
  pages =        "13:1--13:??",
  month =        jun,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3293607",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:01 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3293607",
  abstract =     "We present a new machine-learning algorithm with
                 disjunctive model for data-driven program analysis. One
                 major challenge in static program analysis is a
                 substantial amount of manual effort required for tuning
                 the analysis performance. Recently, data-driven program
                 analysis has emerged to address this challenge by
                 automatically adjusting the analysis based on data
                 through a learning algorithm. Although this new
                 approach has proven promising for various program
                 analysis tasks, its effectiveness has been limited due
                 to simple-minded learning models and algorithms that
                 are unable to capture sophisticated, in particular
                 disjunctive, program properties. To overcome this
                 shortcoming, this article presents a new disjunctive
                 model for data-driven program analysis as well as a
                 learning algorithm to find the model parameters. Our
                 model uses Boolean formulas over atomic features and
                 therefore is able to express nonlinear combinations of
                 program properties. A key technical challenge is to
                 efficiently determine a set of good Boolean formulas,
                 as brute-force search would simply be impractical. We
                 present a stepwise and greedy algorithm that
                 efficiently learns Boolean formulas. We show the
                 effectiveness and generality of our algorithm with two
                 static analyzers: context-sensitive points-to analysis
                 for Java and flow-sensitive interval analysis for C.
                 Experimental results show that our automated technique
                 significantly improves the performance of the
                 state-of-the-art techniques including ones hand-crafted
                 by human experts.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Facchinetti:2019:HOD,
  author =       "Leandro Facchinetti and Zachary Palmer and Scott
                 Smith",
  title =        "Higher-order Demand-driven Program Analysis",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "14:1--14:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3310340",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3310340",
  abstract =     "Developing accurate and efficient program analyses for
                 languages with higher-order functions is known to be
                 difficult. Here we define a new higher-order program
                 analysis, Demand-Driven Program Analysis (DDPA), which
                 extends well-known demand-driven lookup techniques
                 found in first-order program analyses to higher-order
                 programs. This task presents several unique challenges
                 to obtain good accuracy, including the need for a new
                 method for demand-driven lookup of non-local variable
                 values. DDPA is flow- and context-sensitive and
                 provably polynomial-time. To efficiently implement
                 DDPA, we develop a novel pushdown automaton
                 metaprogramming framework, the Pushdown Reachability
                 automaton. The analysis is formalized and proved sound,
                 and an implementation is described.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Grove:2019:FRR,
  author =       "David Grove and Sara S. Hamouda and Benjamin Herta and
                 Arun Iyengar and Kiyokuni Kawachiya and Josh Milthorpe
                 and Vijay Saraswat and Avraham Shinnar and Mikio
                 Takeuchi and Olivier Tardieu",
  title =        "Failure Recovery in Resilient {X10}",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "15:1--15:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3332372",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3332372",
  abstract =     "Cloud computing has made the resources needed to
                 execute large-scale in-memory distributed computations
                 widely available. Specialized programming models, e.g.,
                 MapReduce, have emerged to offer transparent fault
                 tolerance and fault recovery for specific computational
                 patterns, but they sacrifice generality. In contrast,
                 the Resilient X10 programming language adds failure
                 containment and failure awareness to a general purpose,
                 distributed programming language. A Resilient X10
                 application spans over a number of places. Its formal
                 semantics precisely specify how it continues executing
                 after a place failure. Thanks to failure awareness, the
                 X10 programmer can in principle build redundancy into
                 an application to recover from failures. In practice,
                 however, correctness is elusive, as redundancy and
                 recovery are often complex programming tasks. This
                 article further develops Resilient X10 to shift the
                 focus from failure awareness to failure recovery, from
                 both a theoretical and a practical standpoint. We
                 rigorously define the distinction between recoverable
                 and catastrophic failures. We revisit the
                 happens-before invariance principle and its
                 implementation. We shift most of the burden of
                 redundancy and recovery from the programmer to the
                 runtime system and standard library. We make it easy to
                 protect critical data from failure using resilient
                 stores and harness elasticity-dynamic place creation-to
                 persist not just the data but also its spatial
                 distribution. We demonstrate the flexibility and
                 practical usefulness of Resilient X10 by building
                 several representative high-performance in-memory
                 parallel application kernels and frameworks. These
                 codes are $ 10 \times $ to $ 25 \times $ larger than
                 previous Resilient X10 benchmarks. For each application
                 kernel, the average runtime overhead of resiliency is
                 less than 7\%. By comparing application kernels written
                 in the Resilient X10 and Spark programming models, we
                 demonstrate that Resilient X10's more general
                 programming model can enable significantly better
                 application performance for resilient in-memory
                 distributed computations.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Thakur:2019:PFP,
  author =       "Manas Thakur and V. Krishna Nandivada",
  title =        "{PYE}: a Framework for Precise-Yet-Efficient
                 Just-In-Time Analyses for {Java} Programs",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "16:1--16:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3337794",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3337794",
  abstract =     "Languages like Java and C\# follow a two-step process
                 of compilation: static compilation and just-in-time
                 (JIT) compilation. As the time spent in JIT compilation
                 gets added to the execution-time of the application,
                 JIT compilers typically sacrifice the precision of
                 program analyses for efficiency. The alternative of
                 performing the analysis for the whole program
                 statically ignores the analysis of libraries (available
                 only at runtime), and thereby generates imprecise
                 results. To address these issues, in this article, we
                 propose a two-step (static+JIT) analysis framework
                 called precise-yet-efficient (PYE) that helps generate
                 precise analysis-results at runtime at a very low cost.
                 PYE achieves the twin objectives of precision and
                 performance during JIT compilation by using a
                 two-pronged approach: (i) It performs expensive
                 analyses during static compilation, while accounting
                 for the unavailability of the runtime libraries by
                 generating partial results, in terms of conditional
                 values, for the input application. (ii) During JIT
                 compilation, PYE resolves the conditions associated
                 with these values, using the pre-computed conditional
                 values for the libraries, to generate the final
                 results. We have implemented the static and the runtime
                 components of PYE in the Soot optimization framework
                 and the OpenJDK HotSpot Server Compiler (C2),
                 respectively. We demonstrate the usability of PYE by
                 instantiating it to perform two context-, flow-, and
                 field-sensitive heap-based analyses: (i) points-to
                 analysis for null-dereference-check elimination; and
                 (ii) escape analysis for synchronization elimination.
                 We evaluate these instantiations against their
                 corresponding state-of-the-art implementations in C2
                 over a wide range of benchmarks. The extensive
                 evaluation results show that our strategy works quite
                 well and fulfills both the promises it makes: enhanced
                 precision while maintaining efficiency during JIT
                 compilation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Lozano:2019:CRA,
  author =       "Roberto Casta{\~n}eda Lozano and Mats Carlsson and
                 Gabriel Hjort Blindell and Christian Schulte",
  title =        "Combinatorial Register Allocation and Instruction
                 Scheduling",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "17:1--17:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3332373",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3332373",
  abstract =     "This article introduces a combinatorial optimization
                 approach to register allocation and instruction
                 scheduling, two central compiler problems.
                 Combinatorial optimization has the potential to solve
                 these problems optimally and to exploit
                 processor-specific features readily. Our approach is
                 the first to leverage this potential in practice: it
                 captures the complete set of program transformations
                 used in state-of-the-art compilers, scales to
                 medium-sized functions of up to 1,000 instructions, and
                 generates executable code. This level of practicality
                 is reached by using constraint programming, a
                 particularly suitable combinatorial optimization
                 technique. Unison, the implementation of our approach,
                 is open source, used in industry, and integrated with
                 the LLVM toolchain. An extensive evaluation confirms
                 that Unison generates better code than LLVM while
                 scaling to medium-sized functions. The evaluation uses
                 systematically selected benchmarks from MediaBench and
                 SPEC CPU2006 and different processor architectures
                 (Hexagon, ARM, MIPS). Mean estimated speedup ranges
                 from 1.1\% to 10\% and mean code size reduction ranges
                 from 1.3\% to 3.8\% for the different architectures. A
                 significant part of this improvement is due to the
                 integrated nature of the approach. Executing the
                 generated code on Hexagon confirms that the estimated
                 speedup results in actual speedup. Given a fixed time
                 limit, Unison solves optimally functions of up to 946
                 instructions, nearly an order of magnitude larger than
                 previous approaches. The results show that our
                 combinatorial approach can be applied in practice to
                 trade compilation time for code quality beyond the
                 usual compiler optimization levels, identify
                 improvement opportunities in heuristic algorithms, and
                 fully exploit processor-specific features.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Spoto:2019:SII,
  author =       "Fausto Spoto and Elisa Burato and Michael D. Ernst and
                 Pietro Ferrara and Alberto Lovato and Damiano Macedonio
                 and Ciprian Spiridon",
  title =        "Static Identification of Injection Attacks in {Java}",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "18:1--18:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3332371",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3332371",
  abstract =     "The most dangerous security-related software errors,
                 according to the OWASP Top Ten 2017 list, affect web
                 applications. They are potential injection attacks that
                 exploit user-provided data to execute undesired
                 operations: database access and updates ( SQL injection
                 ); generation of malicious web pages ( cross-site
                 scripting injection ); redirection to user-specified
                 web pages ( redirect injection ); execution of OS
                 commands and arbitrary scripts ( command injection );
                 loading of user-specified, possibly heavy or dangerous
                 classes at run time ( reflection injection ); access to
                 arbitrary files on the file system ( path-traversal );
                 and storing user-provided data into heap regions
                 normally assumed to be shielded from the outside world
                 ( trust boundary violation ). All these attacks exploit
                 the same weakness: unconstrained propagation of data
                 from sources that the user of a web application
                 controls into sinks whose activation might trigger
                 dangerous operations. Although web applications are
                 written in a variety of languages, Java remains a
                 frequent choice, in particular for banking
                 applications, where security has tangible relevance.
                 This article defines a unified, sound protection
                 mechanism against such attacks, based on the
                 identification of all possible explicit flows of
                 tainted data in Java code. Such flows can be
                 arbitrarily complex, passing through dynamically
                 allocated data structures in the heap. The analysis is
                 based on abstract interpretation and is
                 interprocedural, flow-sensitive, and context-sensitive.
                 Its notion of taint applies to reference
                 (non-primitive) types dynamically allocated in the heap
                 and is object-sensitive and field-sensitive. The
                 analysis works by translating the program into Boolean
                 formulas that model all possible data flows. Its
                 implementation, within the Julia analyzer for Java and
                 Android, found injection security vulnerabilities in
                 the Internet banking service and in the customer
                 relationship management of large Italian banks, as well
                 as in a set of open-source third-party applications. It
                 found the command injection, which is at the origin of
                 the 2017 Equifax data breach, one of the worst data
                 breaches ever. For objective, repeatable results, this
                 article also evaluates the implementation on two
                 open-source security benchmarks: the Juliet Suite and
                 the OWASP Benchmark for the automatic comparison of
                 static analyzers for cybersecurity. We compared this
                 technique against more than 10 other static analyzers,
                 both free and commercial. The result of these
                 experiments is that ours is the only analysis for
                 injection that is sound (up to well-stated limitations
                 such as multithreading and native code) and works on
                 industrial code, and it is also much more precise than
                 other tools.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Rosa:2019:AOT,
  author =       "Andrea Ros{\`a} and Eduardo Rosales and Walter
                 Binder",
  title =        "Analysis and Optimization of Task Granularity on the
                 {Java Virtual Machine}",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "3",
  pages =        "19:1--19:??",
  month =        jul,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3338497",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3338497",
  abstract =     "Task granularity, i.e., the amount of work performed
                 by parallel tasks, is a key performance attribute of
                 parallel applications. On the one hand, fine-grained
                 tasks (i.e., small tasks carrying out few computations)
                 may introduce considerable parallelization overheads.
                 On the other hand, coarse-grained tasks (i.e., large
                 tasks performing substantial computations) may not
                 fully utilize the available CPU cores, leading to
                 missed parallelization opportunities. In this article,
                 we provide a better understanding of task granularity
                 for task-parallel applications running on a single Java
                 Virtual Machine in a shared-memory multicore. We
                 present a new methodology to accurately and efficiently
                 collect the granularity of each executed task,
                 implemented in a novel profiler (available open-source)
                 that collects carefully selected metrics from the whole
                 system stack with low overhead, and helps developers
                 locate performance and scalability problems. We analyze
                 task granularity in the DaCapo, ScalaBench, and Spark
                 Perf benchmark suites, revealing inefficiencies related
                 to fine-grained and coarse-grained tasks in several
                 applications. We demonstrate that the collected
                 task-granularity profiles are actionable by optimizing
                 task granularity in several applications, achieving
                 speedups up to a factor of $ 5.90 \times $. Our results
                 highlight the importance of analyzing and optimizing
                 task granularity on the Java Virtual Machine.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chatterjee:2019:NPW,
  author =       "Krishnendu Chatterjee and Hongfei Fu and Amir Kafshdar
                 Goharshady",
  title =        "Non-polynomial Worst-Case Analysis of Recursive
                 Programs",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "4",
  pages =        "20:1--20:??",
  month =        nov,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3339984",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fibquart.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3339984",
  abstract =     "We study the problem of developing efficient
                 approaches for proving worst-case bounds of
                 non-deterministic recursive programs. Ranking functions
                 are sound and complete for proving termination and
                 worst-case bounds of non-recursive programs. First, we
                 apply ranking functions to recursion, resulting in
                 measure functions. We show that measure functions
                 provide a sound and complete approach to prove
                 worst-case bounds of non-deterministic recursive
                 programs. Our second contribution is the synthesis of
                 measure functions in non-polynomial forms. We show that
                 non-polynomial measure functions with logarithm and
                 exponentiation can be synthesized through abstraction
                 of logarithmic or exponentiation terms, Farkas Lemma,
                 and Handelman's Theorem using linear programming. While
                 previous methods obtain polynomial worst-case bounds,
                 our approach can synthesize bounds of various forms
                 including O( n log n ) and O( n$^r$ ), where r is not
                 an integer. We present experimental results to
                 demonstrate that our approach can efficiently obtain
                 worst-case bounds of classical recursive algorithms
                 such as (i) Merge sort, Heap sort, and the
                 divide-and-conquer algorithm for the Closest Pair
                 problem, where we obtain O( n log n ) worst-case bound,
                 and (ii) Karatsuba's algorithm for polynomial
                 multiplication and Strassen's algorithm for matrix
                 multiplication, for which we obtain O( n$^r$ ) bounds
                 such that r is not an integer and is close to the
                 best-known bound for the respective algorithm. Besides
                 the ability to synthesize non-polynomial bounds, we
                 also show that our approach is equally capable of
                 obtaining polynomial worst-case bounds for classical
                 programs such as Quick sort and the dynamic programming
                 algorithm for computing Fibonacci numbers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Berger:2019:IPL,
  author =       "Emery D. Berger and Celeste Hollenbeck and Petr Maj
                 and Olga Vitek and Jan Vitek",
  title =        "On the Impact of Programming Languages on Code
                 Quality: a Reproduction Study",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "4",
  pages =        "21:1--21:??",
  month =        nov,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3340571",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3340571",
  abstract =     "In a 2014 article, Ray, Posnett, Devanbu, and Filkov
                 claimed to have uncovered a statistically significant
                 association between 11 programming languages and
                 software defects in 729 projects hosted on GitHub.
                 Specifically, their work answered four research
                 questions relating to software defects and programming
                 languages. With data and code provided by the authors,
                 the present article first attempts to conduct an
                 experimental repetition of the original study. The
                 repetition is only partially successful, due to missing
                 code and issues with the classification of languages.
                 The second part of this work focuses on their main
                 claim, the association between bugs and languages, and
                 performs a complete, independent reanalysis of the data
                 and of the statistical modeling steps undertaken by Ray
                 et al. in 2014. This reanalysis uncovers a number of
                 serious flaws that reduce the number of languages with
                 an association with defects down from 11 to only 4.
                 Moreover, the practical effect size is exceedingly
                 small. These results thus undermine the conclusions of
                 the original study. Correcting the record is important,
                 as many subsequent works have cited the 2014 article
                 and have asserted, without evidence, a causal link
                 between the choice of programming language for a given
                 task and the number of software defects. Causation is
                 not supported by the data at hand; and, in our opinion,
                 even after fixing the methodological flaws we
                 uncovered, too many unaccounted sources of bias remain
                 to hope for a meaningful comparison of bug rates across
                 languages.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Sangiorgi:2019:EBP,
  author =       "Davide Sangiorgi and Valeria Vignudelli",
  title =        "Environmental Bisimulations for Probabilistic
                 Higher-order Languages",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "4",
  pages =        "22:1--22:??",
  month =        nov,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3350618",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3350618",
  abstract =     "Environmental bisimulations for probabilistic
                 higher-order languages are studied. In contrast with
                 applicative bisimulations, environmental bisimulations
                 are known to be more robust and do not require
                 sophisticated techniques such as Howe's in the proofs
                 of congruence. As representative calculi, call-by-name
                 and call-by-value $ \lambda $-calculus, and a
                 (call-by-value) $ \lambda $-calculus extended with
                 references (i.e., a store) are considered. In each
                 case, full abstraction results are derived for
                 probabilistic environmental similarity and bisimilarity
                 with respect to contextual preorder and contextual
                 equivalence, respectively. Some possible enhancements
                 of the (bi)simulations, as ``up-to techniques,'' are
                 also presented. Probabilities force a number of
                 modifications to the definition of environmental
                 bisimulations in non-probabilistic languages. Some of
                 these modifications are specific to probabilities,
                 others may be seen as general refinements of
                 environmental bisimulations, applicable also to
                 non-probabilistic languages. Several examples are
                 presented, to illustrate the modifications and the
                 differences.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Chatterjee:2019:FAD,
  author =       "Krishnendu Chatterjee and Amir Kafshdar Goharshady and
                 Prateesh Goyal and Rasmus Ibsen-Jensen and Andreas
                 Pavlogiannis",
  title =        "Faster Algorithms for Dynamic Algebraic Queries in
                 Basic {RSMs} with Constant Treewidth",
  journal =      j-TOPLAS,
  volume =       "41",
  number =       "4",
  pages =        "23:1--23:??",
  month =        nov,
  year =         "2019",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3363525",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Nov 23 07:18:02 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3363525",
  abstract =     "Interprocedural analysis is at the heart of numerous
                 applications in programming languages, such as alias
                 analysis, constant propagation, and so on. Recursive
                 state machines (RSMs) are standard models for
                 interprocedural analysis. We consider a general
                 framework with RSMs where the transitions are labeled
                 from a semiring and path properties are algebraic with
                 semiring operations. RSMs with algebraic path
                 properties can model interprocedural dataflow analysis
                 problems, the shortest path problem, the most probable
                 path problem, and so on. The traditional algorithms for
                 interprocedural analysis focus on path properties where
                 the starting point is fixed as the entry point of a
                 specific method. In this work, we consider possible
                 multiple queries as required in many applications such
                 as in alias analysis. The study of multiple queries
                 allows us to bring in an important algorithmic
                 distinction between the resource usage of the one-time
                 preprocessing vs for each individual query. The second
                 aspect we consider is that the control flow graphs for
                 most programs have constant treewidth. Our main
                 contributions are simple and implementable algorithms
                 that support multiple queries for algebraic path
                 properties for RSMs that have constant treewidth. Our
                 theoretical results show that our algorithms have small
                 additional one-time preprocessing but can answer
                 subsequent queries significantly faster as compared to
                 the current algorithmic solutions for interprocedural
                 dataflow analysis. We have also implemented our
                 algorithms and evaluated their performance for
                 performing on-demand interprocedural dataflow analysis
                 on various domains, such as for live variable analysis
                 and reaching definitions, on a standard benchmark set.
                 Our experimental results align with our theoretical
                 statements and show that after a lightweight
                 preprocessing, on-demand queries are answered much
                 faster than the standard existing algorithmic
                 approaches.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ahmed:2020:ISI,
  author =       "Amal Ahmed",
  title =        "Introduction to the Special Issue on {ESOP 2018}",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "1",
  pages =        "1--1",
  month =        jan,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3368252",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 11 08:46:19 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3368252",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Xie:2020:CSA,
  author =       "Ningning Xie and Xuan Bi and Bruno C. D. S. Oliveira
                 and Tom Schrijvers",
  title =        "Consistent Subtyping for All",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "1",
  pages =        "2:1--2:??",
  month =        jan,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3310339",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 11 07:29:54 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3310339",
  abstract =     "Consistent subtyping is employed in some gradual type
                 systems to validate type conversions. The original
                 definition by Siek and Taha serves as a guideline for
                 designing gradual type systems with subtyping.
                 Polymorphic types {\`a} la System F also induce a
                 subtyping relation that relates polymorphic types to
                 their instantiations. However, Siek and Taha's
                 definition is not adequate for polymorphic subtyping.
                 The first goal of this article is to propose a
                 generalization of consistent subtyping that is adequate
                 for polymorphic subtyping and subsumes the original
                 definition by Siek and Taha. The new definition of
                 consistent subtyping provides novel insights with
                 respect to previous polymorphic gradual type systems,
                 which did not employ consistent subtyping. The second
                 goal of this article is to present a gradually typed
                 calculus for implicit (higher-rank) polymorphism that
                 uses our new notion of consistent subtyping. We develop
                 both declarative and (bidirectional) algorithmic
                 versions for the type system. The algorithmic version
                 employs techniques developed by Dunfield and
                 Krishnaswami for higher-rank polymorphism to deal with
                 instantiation. We prove that the new calculus satisfies
                 all static aspects of the refined criteria for gradual
                 typing. We also study an extension of the type system
                 with static and gradual type parameters, in an attempt
                 to support a variant of the dynamic criterion for
                 gradual typing. Assuming a coherence conjecture for the
                 extended calculus, we show that the dynamic gradual
                 guarantee of our source language can be reduced to that
                 of $ \lambda B $, which, at the time of writing, is
                 still an open question. Most of the metatheory of this
                 article, except some manual proofs for the algorithmic
                 type system and extensions, has been mechanically
                 formalized using the Coq proof assistant.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Eilers:2020:MPP,
  author =       "Marco Eilers and Peter M{\"u}ller and Samuel Hitz",
  title =        "Modular Product Programs",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "1",
  pages =        "3:1--3:??",
  month =        jan,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3324783",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 11 07:29:54 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3324783",
  abstract =     "Many interesting program properties like determinism
                 or information flow security are hyperproperties, that
                 is, they relate multiple executions of the same
                 program. Hyperproperties can be verified using
                 relational logics, but these logics require dedicated
                 tool support and are difficult to automate.
                 Alternatively, constructions such as self-composition
                 represent multiple executions of a program by one
                 product program, thereby reducing hyperproperties of
                 the original program to trace properties of the
                 product. However, existing constructions do not fully
                 support procedure specifications, for instance, to
                 derive the determinism of a caller from the determinism
                 of a callee, making verification non-modular. We
                 present modular product programs, a novel kind of
                 product program that permits hyperproperties in
                 procedure specifications and, thus, can reason about
                 calls modularly. We provide a general formalization of
                 our product construction and prove it sound and
                 complete. We demonstrate its expressiveness by applying
                 it to information flow security with advanced features
                 such as declassification and termination-sensitivity.
                 Modular product programs can be verified using
                 off-the-shelf verifiers; we have implemented our
                 approach for both secure information flow and general
                 hyperproperties using the Viper verification
                 infrastructure. Our evaluation demonstrates that
                 modular product programs can be used to prove
                 hyperproperties for challenging examples in reasonable
                 time.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Simpson:2020:BEM,
  author =       "Alex Simpson and Niels Voorneveld",
  title =        "Behavioural Equivalence via Modalities for Algebraic
                 Effects",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "1",
  pages =        "4:1--4:??",
  month =        jan,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3363518",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Dec 11 07:29:54 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3363518",
  abstract =     "The article investigates behavioural equivalence
                 between programs in a call-by-value functional language
                 extended with a signature of (algebraic)
                 effect-triggering operations. Two programs are
                 considered as being behaviourally equivalent if they
                 enjoy the same behavioural properties. To formulate
                 this, we define a logic whose formulas specify
                 behavioural properties. A crucial ingredient is a
                 collection of modalities expressing effect-specific
                 aspects of behaviour. We give a general theory of such
                 modalities. If two conditions, openness and
                 decomposability, are satisfied by the modalities, then
                 the logically specified behavioural equivalence
                 coincides with a modality-defined notion of applicative
                 bisimilarity, which can be proven to be a congruence by
                 a generalisation of Howe's method. We show that the
                 openness and decomposability conditions hold for
                 several examples of algebraic effects: nondeterminism,
                 probabilistic choice, global store, and input/output.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Skorstengaard:2020:RAM,
  author =       "Lau Skorstengaard and Dominique Devriese and Lars
                 Birkedal",
  title =        "Reasoning about a Machine with Local Capabilities:
                 Provably Safe Stack and Return Pointer Management",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "1",
  pages =        "1--53",
  month =        jan,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3363519",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jan 11 08:46:19 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3363519",
  abstract =     "Capability machines provide security guarantees at
                 machine level which makes them an interesting target
                 for secure compilation schemes that provably enforce
                 properties such as control-flow correctness and
                 encapsulation of local state. We provide a \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Amtoft:2020:TSI,
  author =       "Torben Amtoft and Anindya Banerjee",
  title =        "A Theory of Slicing for Imperative Probabilistic
                 Programs",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "6:1--6:71",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3372895",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3372895",
  abstract =     "Dedicated to the memory of Sebastian Danicic. We
                 present a theory for slicing imperative probabilistic
                 programs containing random assignments and ``observe''
                 statements for conditioning. We represent such programs
                 as probabilistic control-flow graphs \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Zhao:2020:DLS,
  author =       "David Zhao and Pavle Suboti{\'c} and Bernhard Scholz",
  title =        "Debugging Large-scale {Datalog}: a Scalable Provenance
                 Evaluation Strategy",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "7:1--7:35",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3379446",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3379446",
  abstract =     "Logic programming languages such as Datalog have
                 become popular as Domain Specific Languages (DSLs) for
                 solving large-scale, real-world problems, in
                 particular, static program analysis and network
                 analysis. The logic specifications that model analysis
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Gharat:2020:GPG,
  author =       "Pritam M. Gharat and Uday P. Khedker and Alan
                 Mycroft",
  title =        "Generalized Points-to Graphs: a Precise and Scalable
                 Abstraction for Points-to Analysis",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "8:1--8:78",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3382092",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3382092",
  abstract =     "Computing precise (fully flow- and context-sensitive)
                 and exhaustive (as against demand-driven) points-to
                 information is known to be expensive. Top-down
                 approaches require repeated analysis of a procedure for
                 separate contexts. Bottom-up approaches need \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Narayanan:2020:SDV,
  author =       "Praveen Narayanan and Chung-chieh Shan",
  title =        "Symbolic Disintegration with a Variety of Base
                 Measures",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "9:1--9:60",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3374208",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3374208",
  abstract =     "Disintegration is a relation on measures and a
                 transformation on probabilistic programs that
                 generalizes density calculation and conditioning, two
                 operations widely used for exact and approximate
                 inference. Existing program transformations that find a
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Li:2020:PAS,
  author =       "Yue Li and Tian Tan and Anders M{\o}ller and Yannis
                 Smaragdakis",
  title =        "A Principled Approach to Selective Context Sensitivity
                 for Pointer Analysis",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "10:1--10:40",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3381915",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3381915",
  abstract =     "Context sensitivity is an essential technique for
                 ensuring high precision in static analyses. It has been
                 observed that applying context sensitivity partially,
                 only on a select subset of the methods, can improve the
                 balance between analysis precision \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Toro:2020:CTD,
  author =       "Mat{\'\i}as Toro and Ronald Garcia and {\'E}ric
                 Tanter",
  title =        "Corrigendum to {``Type-driven Gradual Security with
                 References,'' by Toro et al., ACM Transactions on
                 Programming Languages and Systems (TOPLAS) Volume {\bf
                 40}, Issue 4, Article No. 16}",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "2",
  pages =        "11:1--11:2",
  month =        may,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3387725",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu May 28 08:24:24 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  note =         "See \cite{Toro:2018:TDG}.",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3387725",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Jangda:2020:EFT,
  author =       "Abhinav Jangda and Uday Bondhugula",
  title =        "An Effective Fusion and Tile Size Model for
                 {PolyMage}",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "3",
  pages =        "12:1--12:27",
  month =        dec,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3404846",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:03 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3404846",
  abstract =     "Effective models for fusion of loop nests continue to
                 remain a challenge in both general-purpose and
                 domain-specific language (DSL) compilers. The
                 difficulty often arises from the combinatorial
                 explosion of grouping choices and their interaction
                 with \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Frohn:2020:ILR,
  author =       "Florian Frohn and Matthias Naaf and Marc Brockschmidt
                 and J{\"u}rgen Giesl",
  title =        "Inferring Lower Runtime Bounds for Integer Programs",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "3",
  pages =        "13:1--13:50",
  month =        dec,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3410331",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:03 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3410331",
  abstract =     "We present a technique to infer lower bounds on the
                 worst-case runtime complexity of integer programs,
                 where in contrast to earlier work, our approach is not
                 restricted to tail-recursion. Our technique constructs
                 symbolic representations of program \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Coblenz:2020:OTA,
  author =       "Michael Coblenz and Reed Oei and Tyler Etzel and
                 Paulette Koronkevich and Miles Baker and Yannick Bloem
                 and Brad A. Myers and Joshua Sunshine and Jonathan
                 Aldrich",
  title =        "{Obsidian}: Typestate and Assets for Safer Blockchain
                 Programming",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "3",
  pages =        "14:1--14:82",
  month =        dec,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3417516",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:03 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3417516",
  abstract =     "Blockchain platforms are coming into use for
                 processing critical transactions among participants who
                 have not established mutual trust. Many blockchains are
                 programmable, supporting smart contracts, which
                 maintain persistent state and support transactions that
                 transform the state. Unfortunately, bugs in many smart
                 contracts have been exploited by hackers. Obsidian is a
                 novel programming language with a type system that
                 enables static detection of bugs that are common in
                 smart contracts today. Obsidian is based on a core
                 calculus, Silica, for which we proved type soundness.
                 Obsidian uses typestate to detect improper state
                 manipulation and uses linear types to detect abuse of
                 assets. We integrated a permissions system that encodes
                 a notion of ownership to allow for safe, flexible
                 aliasing. We describe two case studies that evaluate
                 Obsidian s applicability to the domains of parametric
                 insurance and supply chain management, finding that
                 Obsidian s type system facilitates reasoning about
                 high-level states and ownership of resources. We
                 compared our Obsidian implementation to a Solidity
                 implementation, observing that the Solidity
                 implementation requires much boilerplate checking and
                 tracking of state, whereas Obsidian does this work
                 statically.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Melo:2020:TIC,
  author =       "Leandro T. C. Melo and Rodrigo G. Ribeiro and Breno C.
                 F. Guimar{\~a}es and Fernando Magno Quint{\~a}o
                 Pereira",
  title =        "Type Inference for {C}: Applications to the Static
                 Analysis of Incomplete Programs",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "3",
  pages =        "15:1--15:71",
  month =        dec,
  year =         "2020",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3421472",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:03 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3421472",
  abstract =     "Type inference is a feature that is common to a
                 variety of programming languages. While, in the past,
                 it has been prominently present in functional ones
                 (e.g., ML and Haskell), today, many
                 object-oriented/multi-paradigm languages such as C\#
                 and C++ offer, to a certain extent, such a feature.
                 Nevertheless, type inference still is an unexplored
                 subject in the realm of C. In particular, it remains
                 open whether it is possible to devise a technique that
                 encompasses the idiosyncrasies of this language. The
                 first difficulty encountered when tackling this problem
                 is that parsing C requires, not only syntactic, but
                 also semantic information. Yet, greater challenges
                 emerge due to C's intricate type system. In this work,
                 we present a unification-based framework that lets us
                 infer the missing struct, union, enum, and typedef
                 declarations in a program.\par

                 As an application of our technique, we investigate the
                 reconstruction of partial programs. Incomplete source
                 code naturally appears in software development: during
                 design and while evolving, testing, and analyzing
                 programs; therefore, understanding it is a valuable
                 asset. With a reconstructed well-typed program, one
                 can: (i) enable static analysis tools in scenarios
                 where components are absent; (ii) improve precision of
                 zero setup static analysis tools; (iii) apply stub
                 generators, symbolic executors, and testing tools on
                 code snippets; and (iv) provide engineers with an
                 assortment of compilable benchmarks for performance and
                 correctness validation. We evaluate our technique on
                 code from a variety of C libraries, including GNU's
                 Coreutils and on snippets from popular projects such as
                 CPython, FreeBSD, and Git.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Liu:2021:ICU,
  author =       "Peizun Liu and Thomas Wahl and Thomas Reps",
  title =        "Interprocedural Context-Unbounded Program Analysis
                 Using Observation Sequences",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "4",
  pages =        "16:1--16:34",
  month =        feb,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3418583",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:04 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3418583",
  abstract =     "A classical result by Ramalingam about
                 synchronization-sensitive interprocedural program
                 analysis implies that reachability for concurrent
                 threads running recursive \ldots{} (More)",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Swalens:2021:CCC,
  author =       "Janwillem Swalens and Joeri {De Koster} and Wolfgang
                 {De Meuter}",
  title =        "{Chocola}: Composable Concurrency Language",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "4",
  pages =        "17:1--17:56",
  month =        feb,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3427201",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:04 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3427201",
  abstract =     "Programmers often combine different concurrency models
                 in a single program, in each part of the program using
                 the model that fits best. Many programming languages,
                 \ldots{} (More)",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Shen:2021:ALI,
  author =       "Jiasi Shen and Martin C. Rinard",
  title =        "Active Learning for Inference and Regeneration of
                 Applications that Access Databases",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "4",
  pages =        "18:1--18:119",
  month =        feb,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3430952",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:04 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3430952",
  abstract =     "We present Konure, a new system that uses active
                 learning to infer models of applications that retrieve
                 data from relational databases. Konure comprises a
                 domain-specific \ldots{} (More)",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Masud:2021:SCD,
  author =       "Abu Naser Masud and Bj{\"o}rn Lisper",
  title =        "Semantic Correctness of Dependence-based Slicing for
                 Interprocedural, Possibly Nonterminating Programs",
  journal =      j-TOPLAS,
  volume =       "42",
  number =       "4",
  pages =        "19:1--19:56",
  month =        feb,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3434489",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Feb 5 10:23:04 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3434489",
  abstract =     "Existing proofs of correctness for dependence-based
                 slicing methods are limited either to the slicing of
                 intraprocedural programs [2, 39], or the proof is only
                 applicable to a specific \ldots{} (More)",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Patrignani:2021:RSC,
  author =       "Marco Patrignani and Deepak Garg",
  title =        "Robustly Safe Compilation, an Efficient Form of Secure
                 Compilation",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "1",
  pages =        "1:1--1:41",
  month =        apr,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3436809",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 27 08:36:42 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3436809",
  abstract =     "Security-preserving compilers generate compiled code
                 that withstands target-level attacks such as alteration
                 of control flow, data leaks, or memory corruption. Many
                 existing security-preserving compilers are proven to be
                 fully abstract, meaning that they reflect and preserve
                 observational equivalence. Fully abstract compilation
                 is strong and useful but, in certain cases, comes at
                 the cost of requiring expensive runtime constructs in
                 compiled code. These constructs may have no relevance
                 for security, but are needed to accommodate differences
                 between the source and target languages that fully
                 abstract compilation necessarily needs.\par

                 As an alternative to fully abstract compilation, this
                 article explores a different criterion for secure
                 compilation called robustly safe compilation or RSC.
                 Briefly, this criterion means that the compiled code
                 preserves relevant safety properties of the source
                 program against all adversarial contexts interacting
                 with the compiled program. We show that RSC can be
                 proved more easily than fully abstract compilation and
                 also often results in more efficient code. We also
                 present two different proof techniques for establishing
                 that a compiler attains RSC and, to illustrate them,
                 develop three illustrative robustly safe compilers that
                 rely on different target-level protection mechanisms.
                 We then proceed to turn one of our compilers into a
                 fully abstract one and through this example argue that
                 proving RSC can be simpler than proving full
                 abstraction.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Sanan:2021:CCT,
  author =       "David Sanan and Yongwang Zhao and Shang-Wei Lin and
                 Liu Yang",
  title =        "{CSim 2}: Compositional Top-down Verification of
                 Concurrent Systems using Rely-Guarantee",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "1",
  pages =        "2:1--2:46",
  month =        apr,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3436808",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 27 08:36:42 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3436808",
  abstract =     "To make feasible and scalable the verification of
                 large and complex concurrent systems, it is necessary
                 the use of compositional techniques even at the highest
                 abstraction layers. When focusing on the lowest
                 software abstraction layers, such as the implementation
                 or the machine code, the high level of detail of those
                 layers makes the direct verification of properties very
                 difficult and expensive. It is therefore essential to
                 use techniques allowing to simplify the verification on
                 these layers. One technique to tackle this challenge is
                 top-down verification where by means of simulation
                 properties verified on top layers (representing
                 abstract specifications of a system) are propagated
                 down to the lowest layers (that are an implementation
                 of the top layers). There is no need to say that
                 simulation of concurrent systems implies a greater
                 level of complexity, and having compositional
                 techniques to check simulation between layers is also
                 desirable when seeking for both feasibility and
                 scalability of the refinement verification. In this
                 article, we present CSim2 a (compositional)
                 rely-guarantee-based framework for the top-down
                 verification of complex concurrent systems in the
                 Isabelle/HOL theorem prover. CSim2 uses CSimpl, a
                 language with a high degree of expressiveness designed
                 for the specification of concurrent programs. Thanks to
                 its expressibility, CSimpl is able to model many of the
                 features found in real world programming languages like
                 exceptions, assertions, and procedures. CSim2 provides
                 a framework for the verification of rely-guarantee
                 properties to compositionally reason on CSimpl
                 specifications. Focusing on top-down verification,
                 CSim2 provides a simulation-based framework for the
                 preservation of CSimpl rely-guarantee properties from
                 specifications to implementations. By using the
                 simulation framework, properties proven on the top
                 layers (abstract specifications) are compositionally
                 propagated down to the lowest layers (source or machine
                 code) in each concurrent component of the system.
                 Finally, we show the usability of CSim2 by running a
                 case study over two CSimpl specifications of an
                 Arinc-653 communication service. In this case study, we
                 prove a complex property on a specification, and we use
                 CSim2 to preserve the property on lower abstraction
                 layers.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Pearce:2021:LFR,
  author =       "David J. Pearce",
  title =        "A Lightweight Formalism for Reference Lifetimes and
                 Borrowing in {Rust}",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "1",
  pages =        "3:1--3:73",
  month =        apr,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3443420",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 27 08:36:42 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3443420",
  abstract =     "Rust is a relatively new programming language that has
                 gained significant traction since its v1.0 release in
                 2015. Rust aims to be a systems language that competes
                 with C/C++. A claimed advantage of Rust is a strong
                 focus on memory safety without garbage collection. This
                 is primarily achieved through two concepts, namely,
                 reference lifetimes and borrowing. Both of these are
                 well-known ideas stemming from the literature on
                 region-based memory management and
                 linearity/uniqueness. Rust brings both of these ideas
                 together to form a coherent programming model.
                 Furthermore, Rust has a strong focus on stack-allocated
                 data and, like C/C++ but unlike Java, permits
                 references to local variables.\par

                 Type checking in Rust can be viewed as a two-phase
                 process: First, a traditional type checker operates in
                 a flow-insensitive fashion; second, a borrow checker
                 enforces an ownership invariant using a flow-sensitive
                 analysis. In this article, we present a lightweight
                 formalism that captures these two phases using a
                 flow-sensitive type system that enforces ``type and
                 borrow safety.'' In particular, programs that are type
                 and borrow safe will not attempt to dereference
                 dangling pointers. Our calculus core captures many
                 aspects of Rust, including copy- and move-semantics,
                 mutable borrowing, reborrowing, partial moves, and
                 lifetimes. In particular, it remains sufficiently
                 lightweight to be easily digested and understood and,
                 we argue, still captures the salient aspects of
                 reference lifetimes and borrowing. Furthermore,
                 extensions to the core can easily add more complex
                 features (e.g., control-flow, tuples, method
                 invocation). We provide a soundness proof to verify our
                 key claims of the calculus. We also provide a reference
                 implementation in Java with which we have model checked
                 our calculus using over 500B input programs. We have
                 also fuzz tested the Rust compiler using our calculus
                 against 2B programs and, to date, found one confirmed
                 compiler bug and several other possible issues.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Gordon:2021:PIS,
  author =       "Colin S. Gordon",
  title =        "Polymorphic Iterable Sequential Effect Systems",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "1",
  pages =        "4:1--4:79",
  month =        apr,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3450272",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Apr 27 08:36:42 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450272",
  abstract =     "Effect systems are lightweight extensions to type
                 systems that can verify a wide range of important
                 properties with modest developer burden. But our
                 general understanding of effect systems is limited
                 primarily to systems where the order of effects is
                 irrelevant. Understanding such systems in terms of a
                 semilattice of effects grounds understanding of the
                 essential issues and provides guidance when designing
                 new effect systems. By contrast, sequential effect
                 systems --- where the order of effects is important ---
                 lack an established algebraic structure on
                 effects.\par

                 We present an abstract polymorphic effect system
                 parameterized by an effect quantale --- an algebraic
                 structure with well-defined properties that can model
                 the effects of a range of existing sequential effect
                 systems. We define effect quantales, derive useful
                 properties, and show how they cleanly model a variety
                 of known sequential effect systems.\par

                 We show that for most effect quantales, there is an
                 induced notion of iterating a sequential effect; that
                 for systems we consider the derived iteration agrees
                 with the manually designed iteration operators in prior
                 work; and that this induced notion of iteration is as
                 precise as possible when defined. We also position
                 effect quantales with respect to work on categorical
                 semantics for sequential effect systems, clarifying the
                 distinctions between these systems and our own in the
                 course of giving a thorough survey of these frameworks.
                 Our derived iteration construct should generalize to
                 these semantic structures, addressing limitations of
                 that work. Finally, we consider the relationship
                 between sequential effects and Kleene Algebras, where
                 the latter may be used as instances of the former.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Takisaka:2021:RRS,
  author =       "Toru Takisaka and Yuichiro Oyabu and Natsuki Urabe and
                 Ichiro Hasuo",
  title =        "Ranking and Repulsing Supermartingales for
                 Reachability in Randomized Programs",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "2",
  pages =        "5:1--5:46",
  month =        jul,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3450967",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jul 24 07:06:28 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3450967",
  abstract =     "Computing reachability probabilities is a fundamental
                 problem in the analysis of randomized programs. This
                 article aims at a comprehensive and comparative account
                 of various martingale-based methods for over- and
                 under-approximating reachability \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lobo-Vesga:2021:PLD,
  author =       "Elisabet Lobo-Vesga and Alejandro Russo and Marco
                 Gaboardi",
  title =        "A Programming Language for Data Privacy with Accuracy
                 Estimations",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "2",
  pages =        "6:1--6:42",
  month =        jul,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3452096",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jul 24 07:06:28 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3452096",
  abstract =     "Differential privacy offers a formal framework for
                 reasoning about the privacy and accuracy of
                 computations on private data. It also offers a rich set
                 of building blocks for constructing private data
                 analyses. When carefully calibrated, these analyses
                 simultaneously guarantee the privacy of the individuals
                 contributing their data, and the accuracy of the data
                 analysis results, inferring useful properties about the
                 population. The compositional nature of differential
                 privacy has motivated the design and implementation of
                 several programming languages to ease the
                 implementation of differentially private analyses. Even
                 though these programming languages provide support for
                 reasoning about privacy, most of them disregard
                 reasoning about the accuracy of data analyses. To
                 overcome this limitation, we present DPella, a
                 programming framework providing data analysts with
                 support for reasoning about privacy, accuracy, and
                 their trade-offs. The distinguishing feature of DPella
                 is a novel component that statically tracks the
                 accuracy of different data analyses. To provide tight
                 accuracy estimations, this component leverages taint
                 analysis for automatically inferring statistical
                 independence of the different noise quantities added
                 for guaranteeing privacy. We evaluate our approach by
                 implementing several classical queries from the
                 literature and showing how data analysts can calibrate
                 the privacy parameters to meet the accuracy
                 requirements, and vice versa.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Toninho:2021:PSF,
  author =       "Bernardo Toninho and Nobuko Yoshida",
  title =        "On Polymorphic Sessions and Functions: a Tale of Two
                 (Fully Abstract) Encodings",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "2",
  pages =        "7:1--7:55",
  month =        jul,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3457884",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jul 24 07:06:28 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3457884",
  abstract =     "This work exploits the logical foundation of session
                 types to determine what kind of type discipline for the
                 \Lambda -calculus can exactly capture, and is captured
                 by, \Lambda -calculus behaviours. Leveraging the proof
                 theoretic content of the soundness and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Alglave:2021:ACF,
  author =       "Jade Alglave and Will Deacon and Richard Grisenthwaite
                 and Antoine Hacquard and Luc Maranget",
  title =        "Armed Cats: Formal Concurrency Modelling at {Arm}",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "2",
  pages =        "8:1--8:54",
  month =        jul,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3458926",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Jul 24 07:06:28 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3458926",
  abstract =     "We report on the process for formal concurrency
                 modelling at Arm. An initial formal consistency model
                 of the Arm architecture, written in the cat language,
                 was published and upstreamed to the herd+diy tool suite
                 in 2017. Since then, we have extended the original
                 model with extra features, for example, mixed-size
                 accesses, and produced two provably equivalent
                 alternative formulations.\par

                 In this article, we present a comprehensive review of
                 work done at Arm on the consistency model. Along the
                 way, we also show that our principle for handling
                 mixed-size accesses applies to x86: We confirm this via
                 vast experimental campaigns. We also show that our
                 alternative formulations are applicable to any model
                 phrased in a style similar to the one chosen by Arm.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Zhang:2021:CP,
  author =       "Weixin Zhang and Yaozhu Sun and Bruno C. D. S.
                 Oliveira",
  title =        "Compositional Programming",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "3",
  pages =        "9:1--9:61",
  month =        sep,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3460228",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 14 07:20:02 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3460228",
  abstract =     "Modularity is a key concern in programming. However,
                 programming languages remain limited in terms of
                 modularity and extensibility. Small canonical problems,
                 such as the Expression Problem (EP), illustrate some of
                 the basic issues: the dilemma between \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Liu:2021:SDC,
  author =       "Lun Liu and Todd Millstein and Madanlal Musuvathi",
  title =        "Safe-by-default Concurrency for Modern Programming
                 Languages",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "3",
  pages =        "10:1--10:50",
  month =        sep,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3462206",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 14 07:20:02 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/julia.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3462206",
  abstract =     "Modern ``safe'' programming languages follow a design
                 principle that we call safety by default and
                 performance by choice. By default, these languages
                 enforce important programming abstractions, such as
                 memory and type safety, but they also provide
                 mechanisms that allow expert programmers to explicitly
                 trade some safety guarantees for increased performance.
                 However, these same languages have adopted the inverse
                 design principle in their support for multithreading.
                 By default, multithreaded programs violate important
                 abstractions, such as program order and atomic access
                 to individual memory locations to admit compiler and
                 hardware optimizations that would otherwise need to be
                 restricted. Not only does this approach conflict with
                 the design philosophy of safe languages, but very
                 little is known about the practical performance cost of
                 providing a stronger default semantics.

                 In this article, we propose a safe-by-default and
                 performance-by-choice multithreading semantics for safe
                 languages, which we call volatile-by-default. Under
                 this semantics, programs have sequential consistency
                 (SC) by default, which is the natural ``interleaving''
                 semantics of threads. However, the volatile-by-default
                 design also includes annotations that allow expert
                 programmers to avoid the associated overheads in
                 performance-critical code. We describe the design,
                 implementation, optimization, and evaluation of the
                 volatile-by-default semantics for two different safe
                 languages: Java and Julia. First, we present
                 VBD-HotSpot and VBDA-HotSpot, modifications of Oracle's
                 HotSpot JVM that enforce the volatile-by-default
                 semantics on Intel x86-64 hardware and ARM-v8 hardware.
                 Second, we present SC-Julia, a modification to the
                 just-in-time compiler within the standard Julia
                 implementation that provides best-effort enforcement of
                 the volatile-by-default semantics on x86-64 hardware
                 for the purpose of performance evaluation. We also
                 detail two different implementation techniques: a
                 baseline approach that simply reuses existing
                 mechanisms in the compilers for handling atomic
                 accesses, and a speculative approach that avoids the
                 overhead of enforcing the volatile-by-default semantics
                 until there is the possibility of an SC violation. Our
                 results show that the cost of enforcing SC is
                 significant but arguably still acceptable for some use
                 cases today. Further, we demonstrate that compiler
                 optimizations as well as programmer annotations can
                 reduce the overhead considerably.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Gange:2021:FLZ,
  author =       "Graeme Gange and Zequn Ma and Jorge A. Navas and Peter
                 Schachte and Harald S{\o}ndergaard and Peter J.
                 Stuckey",
  title =        "A Fresh Look at Zones and Octagons",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "3",
  pages =        "11:1--11:51",
  month =        sep,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3457885",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 14 07:20:02 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3457885",
  abstract =     "Zones and Octagons are popular abstract domains for
                 static program analysis. They enable the automated
                 discovery of simple numerical relations that hold
                 between pairs of program variables. Both domains are
                 well understood mathematically but the detailed
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Busi:2021:SIE,
  author =       "Matteo Busi and Job Noorman and Jo {Van Bulck} and
                 Letterio Galletta and Pierpaolo Degano and Jan Tobias
                 M{\"u}hlberg and Frank Piessens",
  title =        "Securing Interruptible Enclaved Execution on Small
                 Microprocessors",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "3",
  pages =        "12:1--12:77",
  month =        sep,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3470534",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Sep 14 07:20:02 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3470534",
  abstract =     "Computer systems often provide hardware support for
                 isolation mechanisms such as privilege levels, virtual
                 memory, or enclaved execution. Over the past years,
                 several successful software-based side-channel attacks
                 have been developed that break, or at \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Muller:2021:ISS,
  author =       "Peter M{\"u}ller",
  title =        "Introduction to the Special Section on {ESOP 2020}",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "4",
  pages =        "13:1--13:1",
  month =        dec,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3484490",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Dec 17 15:53:27 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3484490",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Abate:2021:EAT,
  author =       "Carmine Abate and Roberto Blanco and Stefan
                 Ciob{\^a}ca and Adrien Durier and Deepak Garg and
                 Catalin Hrittcu and Marco Patrignani and {\'E}ric
                 Tanter and J{\'e}r{\'e}my Thibault",
  title =        "An Extended Account of Trace-relating Compiler
                 Correctness and Secure Compilation",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "4",
  pages =        "14:1--14:48",
  month =        dec,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3460860",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Dec 17 15:53:27 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3460860",
  abstract =     "Compiler correctness, in its simplest form, is defined
                 as the inclusion of the set of traces of the compiled
                 program in the set of traces of the original program.
                 This is equivalent to the preservation of all trace
                 properties. Here, traces collect, for \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Matsushita:2021:RCB,
  author =       "Yusuke Matsushita and Takeshi Tsukada and Naoki
                 Kobayashi",
  title =        "{RustHorn}: {CHC}-based Verification for {Rust}
                 Programs",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "4",
  pages =        "15:1--15:54",
  month =        dec,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3462205",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Dec 17 15:53:27 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/rust.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3462205",
  abstract =     "Reduction to satisfiability of constrained Horn
                 clauses (CHCs) is a widely studied approach to
                 automated program verification. Current CHC-based
                 methods, however, do not work very well for
                 pointer-manipulating programs, especially those with
                 dynamic memory allocation. This article presents a
                 novel reduction of pointer-manipulating Rust programs
                 into CHCs, which clears away pointers and memory states
                 by leveraging Rust's guarantees on permission. We
                 formalize our reduction for a simplified core of Rust
                 and prove its soundness and completeness. We have
                 implemented a prototype verifier for a subset of Rust
                 and confirmed the effectiveness of our method.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{DOsualdo:2021:TLC,
  author =       "Emanuele D'Osualdo and Julian Sutherland and Azadeh
                 Farzan and Philippa Gardner",
  title =        "{TaDA} Live: Compositional Reasoning for Termination
                 of Fine-grained Concurrent Programs",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "4",
  pages =        "16:1--16:134",
  month =        dec,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3477082",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Dec 17 15:53:27 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477082",
  abstract =     "We present TaDA Live, a concurrent separation logic
                 for reasoning compositionally about the termination of
                 blocking fine-grained concurrent programs. The crucial
                 challenge is how to deal with abstract atomic blocking:
                 that is, abstract atomic operations \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{deBoer:2021:CCR,
  author =       "Frank S. de Boer and Hans-Dieter A. Hiep",
  title =        "Completeness and Complexity of Reasoning about
                 Call-by-Value in {Hoare} Logic",
  journal =      j-TOPLAS,
  volume =       "43",
  number =       "4",
  pages =        "17:1--17:35",
  month =        dec,
  year =         "2021",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3477143",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Dec 17 15:53:27 MST 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3477143",
  abstract =     "We provide a sound and relatively complete Hoare logic
                 for reasoning about partial correctness of recursive
                 procedures in presence of local variables and the
                 call-by-value parameter mechanism and in which the
                 correctness proofs support contracts and are \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Inverso:2022:BVM,
  author =       "Omar Inverso and Ermenegildo Tomasco and Bernd Fischer
                 and Salvatore {La Torre} and Gennaro Parlato",
  title =        "Bounded Verification of Multi-threaded Programs via
                 Lazy Sequentialization",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "1",
  pages =        "1:1--1:50",
  month =        mar,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3478536",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 14 06:53:13 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3478536",
  abstract =     "Bounded verification techniques such as bounded model
                 checking (BMC) have successfully been used for many
                 practical program analysis problems, but concurrency
                 still poses a challenge. Here, we describe a new
                 approach to BMC of sequentially consistent \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Hecker:2022:TSC,
  author =       "Martin Hecker and Simon Bischof and Gregor Snelting",
  title =        "On Time-sensitive Control Dependencies",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "1",
  pages =        "2:1--2:37",
  month =        mar,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3486003",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 14 06:53:13 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3486003",
  abstract =     "We present efficient algorithms for time-sensitive
                 control dependencies (CDs). If statement y is
                 time-sensitively control dependent on statement x, then
                 x decides not only whether y is executed but also how
                 many timesteps after x. If y is not standard \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Deng:2022:SDR,
  author =       "Chaoqiang Deng and Patrick Cousot",
  title =        "The Systematic Design of Responsibility Analysis by
                 Abstract Interpretation",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "1",
  pages =        "3:1--3:90",
  month =        mar,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3484938",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 14 06:53:13 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3484938",
  abstract =     "Given a behavior of interest, automatically
                 determining the corresponding responsible entity (i.e.,
                 the root cause) is a task of critical importance in
                 program static analysis. In this article, a novel
                 definition of responsibility based on the abstraction
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Gorinova:2022:CIT,
  author =       "Maria I. Gorinova and Andrew D. Gordon and Charles
                 Sutton and Matthijs V{\'a}k{\'a}r",
  title =        "Conditional Independence by Typing",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "1",
  pages =        "4:1--4:54",
  month =        mar,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3490421",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 14 06:53:13 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3490421",
  abstract =     "A central goal of probabilistic programming languages
                 (PPLs) is to separate modelling from inference.
                 However, this goal is hard to achieve in practice.
                 Users are often forced to re-write their models to
                 improve efficiency of inference or meet \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Melicher:2022:BAE,
  author =       "Darya Melicher and Anlun Xu and Valerie Zhao and Alex
                 Potanin and Jonathan Aldrich",
  title =        "Bounded Abstract Effects",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "1",
  pages =        "5:1--5:48",
  month =        mar,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3492427",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Jan 14 06:53:13 MST 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3492427",
  abstract =     "Effect systems have been a subject of active research
                 for nearly four decades, with the most notable
                 practical example being checked exceptions in
                 programming languages such as Java. While many
                 exception systems support abstraction, aggregation, and
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lamport:2022:PMS,
  author =       "Leslie Lamport and Stephan Merz",
  title =        "Prophecy Made Simple",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "6:1--6:27",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3492545",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3492545",
  abstract =     "Prophecy variables were introduced in the article
                 ``The Existence of Refinement Mappings'' by Abadi and
                 Lamport. They were difficult to use in practice. We
                 describe a new kind of prophecy variable that we find
                 much easier to use. We also reformulate ideas from that
                 article in a more mathematical way.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lennon-Bertrand:2022:GCI,
  author =       "Meven Lennon-Bertrand and Kenji Maillard and Nicolas
                 Tabareau and {\'E}ric Tanter",
  title =        "Gradualizing the Calculus of Inductive Constructions",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "7:1--7:82",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3495528",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3495528",
  abstract =     "We investigate gradual variations on the Calculus of
                 Inductive Construction (CIC) for swifter prototyping
                 with imprecise types and terms. We observe, with a
                 no-go theorem, a crucial trade-off between graduality
                 and the key properties of normalization and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lahav:2022:WDA,
  author =       "Ori Lahav and Udi Boker",
  title =        "What's Decidable About Causally Consistent Shared
                 Memory?",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "8:1--8:55",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3505273",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3505273",
  abstract =     "While causal consistency is one of the most
                 fundamental consistency models weaker than sequential
                 consistency, the decidability of safety verification
                 for (finite-state) concurrent programs running under
                 causally consistent shared memories is still \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Hu:2022:SPS,
  author =       "Qinheping Hu and Rishabh Singh and Loris D'Antoni",
  title =        "Solving Program Sketches with Large Integer Values",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "9:1--9:28",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3532849",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3532849",
  abstract =     "Program sketching is a program synthesis paradigm in
                 which the programmer provides a partial program with
                 holes and assertions. The goal of the synthesizer is to
                 automatically find integer values for the holes so that
                 the resulting program satisfies the \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Shi:2022:TCP,
  author =       "Kensen Shi and David Bieber and Rishabh Singh",
  title =        "{TF-Coder}: Program Synthesis for Tensor
                 Manipulations",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "10:1--10:36",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3517034",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3517034",
  abstract =     "The success and popularity of deep learning is on the
                 rise, partially due to powerful deep learning
                 frameworks such as TensorFlow and PyTorch, which make
                 it easier to develop deep learning models. However,
                 these libraries also come with steep learning
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Li:2022:FGS,
  author =       "Yuanbo Li and Qirun Zhang and Thomas Reps",
  title =        "Fast Graph Simplification for Interleaved-{Dyck}
                 Reachability",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "11:1--11:28",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3492428",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3492428",
  abstract =     "Many program-analysis problems can be formulated as
                 graph-reachability problems. Interleaved Dyck language
                 reachability (InterDyck-reachability) is a fundamental
                 framework to express a wide variety of program-analysis
                 problems over edge-labeled graphs. \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lorch:2022:AAV,
  author =       "Jacob R. Lorch and Yixuan Chen and Manos Kapritsos and
                 Haojun Ma and Bryan Parno and Shaz Qadeer and Upamanyu
                 Sharma and James R. Wilcox and Xueyuan Zhao",
  title =        "{Armada}: Automated Verification of Concurrent Code
                 with Sound Semantic Extensibility",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "2",
  pages =        "12:1--12:39",
  month =        jun,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3502491",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Jul 21 10:36:42 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3502491",
  abstract =     "Safely writing high-performance concurrent programs is
                 notoriously difficult. To aid developers, we introduce
                 Armada, a language and tool designed to formally verify
                 such programs with relatively little effort. Via a
                 C-like language and a small-step, \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Yoshida:2022:ISI,
  author =       "Nobuko Yoshida",
  title =        "Introduction to the Special Issue on {ESOP 2021}",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "13:1--13:1",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3524730",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3524730",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Haslbeck:2022:FDM,
  author =       "Maximilian P. L. Haslbeck and Peter Lammich",
  title =        "For a Few Dollars More: Verified Fine-Grained
                 Algorithm Analysis Down to {LLVM}",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "14:1--14:36",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3486169",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3486169",
  abstract =     "We present a framework to verify both, functional
                 correctness and (amortized) worst-case complexity of
                 practically efficient algorithms. We implemented a
                 stepwise refinement approach, using the novel concept
                 of resource currencies to naturally structure
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Baillot:2022:TCP,
  author =       "Patrick Baillot and Alexis Ghyselen",
  title =        "Types for Complexity of Parallel Computation in
                 Pi-calculus",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "15:1--15:50",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3495529",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3495529",
  abstract =     "Type systems as a technique to analyse or control
                 programs have been extensively studied for functional
                 programming languages. In particular, some systems
                 allow one to extract from a typing derivation a
                 complexity bound on the program. We explore how to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Pagel:2022:SSL,
  author =       "Jens Pagel and Florian Zuleger",
  title =        "Strong-separation Logic",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "16:1--16:40",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3498847",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3498847",
  abstract =     "Most automated verifiers for separation logic are
                 based on the symbolic-heap fragment, which disallows
                 both the magic-wand operator and the application of
                 classical Boolean operators to spatial formulas. This
                 is not surprising, as support for the magic \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Ish-Shalom:2022:RCB,
  author =       "Oren Ish-Shalom and Shachar Itzhaky and Noam Rinetzky
                 and Sharon Shoham",
  title =        "Runtime Complexity Bounds Using Squeezers",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "17:1--17:36",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3527632",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527632",
  abstract =     "Determining upper bounds on the time complexity of a
                 program is a fundamental problem with a variety of
                 applications, such as performance debugging, resource
                 certification, and compile-time optimizations.
                 Automated techniques for cost analysis excel at
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Keizer:2022:SCC,
  author =       "Alex C. Keizer and Henning Basold and Jorge A.
                 P{\'e}rez",
  title =        "Session Coalgebras: a Coalgebraic View on Regular and
                 Context-free Session Types",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "18:1--18:45",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3527633",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527633",
  abstract =     "Compositional methods are central to the verification
                 of software systems. For concurrent and communicating
                 systems, compositional techniques based on behavioural
                 type systems have received much attention. By
                 abstracting communication protocols as types,
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Das:2022:NST,
  author =       "Ankush Das and Henry Deyoung and Andreia Mordido and
                 Frank Pfenning",
  title =        "Nested Session Types",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "19:1--19:45",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3539656",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3539656",
  abstract =     "Session types statically describe communication
                 protocols between concurrent message-passing processes.
                 Unfortunately, parametric polymorphism even in its
                 restricted prenex form is not fully understood in the
                 context of session types. In this article, we
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Vakar:2022:CCH,
  author =       "Matthijs V{\'a}k{\'a}r and Tom Smeding",
  title =        "{CHAD: Combinatory Homomorphic Automatic
                 Differentiation}",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "3",
  pages =        "20:1--20:49",
  month =        sep,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3527634",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Aug 18 14:01:38 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527634",
  abstract =     "We introduce Combinatory Homomorphic Automatic
                 Differentiation (CHAD), a principled, pure, provably
                 correct define-then-run method for performing forward
                 and reverse mode automatic differentiation (AD) on
                 programming languages with expressive features. It
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Steimann:2022:CPS,
  author =       "Friedrich Steimann",
  title =        "Containerless Plurals: Separating Number from Type in
                 Object-Oriented Programming",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "21:1--21:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3527635",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3527635",
  abstract =     "To let expressions evaluate to no or many objects,
                 most object-oriented programming languages require the
                 use of special constructs that encode these cases as
                 single objects or values. While the requirement to
                 treat these standard situations idiomatically
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Yang:2022:DDZ,
  author =       "Albert Mingkun Yang and Tobias Wrigstad",
  title =        "Deep Dive into {ZGC}: a Modern Garbage Collector in
                 {OpenJDK}",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "22:1--22:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3538532",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3538532",
  abstract =     "ZGC is a modern, non-generational, region-based,
                 mostly concurrent, parallel, mark-evacuate collector
                 recently added to OpenJDK. It aims at having GC pauses
                 that do not grow as the heap size increases, offering
                 low latency even with large heap sizes. The ZGC C++
                 source code is readily accessible in the OpenJDK
                 repository, but reading it (25 KLOC) can be very
                 intimidating, and one might easily get lost in
                 low-level implementation details, obscuring the key
                 concepts. To make the ZGC algorithm more approachable,
                 this work provides a thorough description on a
                 high-level, focusing on the overall design with
                 moderate implementation details. To explain the
                 concurrency aspects, we provide a SPIN model that
                 allows studying races between mutators and GC threads,
                 and how they are resolved in ZGC. Such a model is not
                 only useful for learning the current design (offering a
                 deterministic and interactive experience) but also
                 beneficial for prototyping ew ideas and extensions. Our
                 hope is that our detailed description and the SPIN
                 model will enable the use of ZGC as a building block
                 for future GC research, and research ideas implemented
                 on top of it could even be adopted in the industry more
                 readily, bridging the gap between academia and industry
                 in the context of GC research.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Devriese:2022:TPV,
  author =       "Dominique Devriese and Marco Patrignani and Frank
                 Piessens",
  title =        "Two Parametricities Versus Three Universal Types",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "23:1--23:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3539657",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3539657",
  abstract =     "The formal calculus System F models the essence of
                 polymorphism and abstract data types, features that
                 exist in many programming languages. The calculus' core
                 property is parametricity: a theorem expressing the
                 language's abstractions and validating \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "23",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Zhou:2022:RIR,
  author =       "Yaoda Zhou and Jinxu Zhao and Bruno C. D. S.
                 Oliveira",
  title =        "Revisiting Iso-Recursive Subtyping",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "24:1--24:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3549537",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3549537",
  abstract =     "The Amber rules are well-known and widely used for
                 subtyping iso-recursive types. They were first briefly
                 and informally introduced in 1985 by Cardelli in a
                 manuscript describing the Amber language. Despite their
                 use over many years, important aspects of \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "24",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Banerjee:2022:RPL,
  author =       "Anindya Banerjee and Ramana Nagasamudram and David
                 Naumann and Mohammad Nikouei",
  title =        "A Relational Program Logic with Data Abstraction and
                 Dynamic Framing",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "25:1--25:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3551497",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/h/hoare-c-a-r.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3551497",
  abstract =     "Dedicated to Tony Hoare. In a paper published in 1972,
                 Hoare articulated the fundamental notions of hiding
                 invariants and simulations. Hiding: invariants on
                 encapsulated data representations need not be mentioned
                 in specifications that comprise the API of a module.
                 Simulation: correctness of a new data representation
                 and implementation can be established by proving
                 simulation between the old and new implementations
                 using a coupling relation defined on the encapsulated
                 state. These results were formalized semantically and
                 for a simple model of state, though the paper claimed
                 this could be extended to encompass dynamically
                 allocated objects. In recent years, progress has been
                 made toward formalizing the claim, for simulation,
                 though mainly in semantic developments. In this
                 article, hiding and simulation are combined with the
                 idea in Hoare's 1969 paper: a logic of programs. For an
                 object-based language with dynamic allocation, we
                 introduce a relational Hoare logic with stateful frame
                 conditions that ``formalizes encapsulation, hiding of
                 invariants, and couplings that relate two
                 implementations. Relations and other assertions are
                 expressed in first-order logic. Specifications can
                 express a wide range of relational properties such as
                 conditional equivalence and noninterference with
                 declassification. The proof rules facilitate relational
                 reasoning by means of convenient alignments and are
                 shown sound with respect to a conventional operational
                 semantics. A derived proof rule for equivalence of
                 linked programs directly embodies representation
                 independence. Applicability to representative examples
                 is demonstrated using an SMT-based implementation.",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "25",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Vasconcelos:2022:TDM,
  author =       "Vasco T. Vasconcelos and Francisco Martins and
                 Hugo-Andr{\'e}s L{\'o}pez and Nobuko Yoshida",
  title =        "A Type Discipline for Message Passing Parallel
                 Programs",
  journal =      j-TOPLAS,
  volume =       "44",
  number =       "4",
  pages =        "26:1--26:??",
  month =        dec,
  year =         "2022",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3552519",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Wed Jan 11 07:49:11 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3552519",
  abstract =     "We present ParTypes, a type discipline for parallel
                 programs. The model we have in mind comprises a fixed
                 number of processes running in parallel and
                 communicating via collective operations or
                 point-to-point synchronous message exchanges. A type
                 describes \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "26",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Danvy:2023:THA,
  author =       "Olivier Danvy",
  title =        "The Tortoise and the Hare Algorithm for Finite Lists,
                 Compositionally",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "1:1--1:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3564619",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3564619",
  abstract =     "In the tortoise-and-hare algorithm, when the fast
                 pointer reaches the end of a finite list, the slow
                 pointer points to the middle of this list. In the early
                 2000's, this property was found to make it possible to
                 program a palindrome detector for immutable \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Hu:2023:TPO,
  author =       "Jingmei Hu and Eric Lu and David A. Holland and Ming
                 Kawaguchi and Stephen Chong and Margo Seltzer",
  title =        "Towards Porting Operating Systems with Program
                 Synthesis",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "2:1--2:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3563943",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3563943",
  abstract =     "The end of Moore's Law has ushered in a diversity of
                 hardware not seen in decades. Operating system (OS)
                 (and system software) portability is accordingly
                 becoming increasingly critical. Simultaneously, there
                 has been tremendous progress in program \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "2",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Runge:2023:IES,
  author =       "Tobias Runge and Marco Servetto and Alex Potanin and
                 Ina Schaefer",
  title =        "Immutability and Encapsulation for Sound {OO}
                 Information Flow Control",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "3:1--3:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3573270",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3573270",
  abstract =     "Security-critical software applications contain
                 confidential information which has to be protected from
                 leaking to unauthorized systems. With language-based
                 techniques, the confidentiality of applications can be
                 enforced. Such techniques are for example \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "3",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Greenman:2023:TUI,
  author =       "Ben Greenman and Christos Dimoulas and Matthias
                 Felleisen",
  title =        "Typed-Untyped Interactions: a Comparative Analysis",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "4:1--4:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3579833",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579833",
  abstract =     "The literature presents many strategies for enforcing
                 the integrity of types when typed code interacts with
                 untyped code. This article presents a uniform
                 evaluation framework that characterizes the differences
                 among some major existing semantics for typed-.
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Chargueraud:2023:OSH,
  author =       "Arthur Chargu{\'e}raud and Adam Chlipala and Andres
                 Erbsen and Samuel Gruetter",
  title =        "Omnisemantics: Smooth Handling of Nondeterminism",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "5:1--5:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3579834",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579834",
  abstract =     "This article gives an in-depth presentation of the
                 omni-big-step and omni-small-step styles of semantic
                 judgments. These styles describe operational semantics
                 by relating starting states to sets of outcomes rather
                 than to individual outcomes. A single \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "5",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Fan:2023:SMO,
  author =       "Hongyu Fan and Zhihang Sun and Fei He",
  title =        "Satisfiability Modulo Ordering Consistency Theory for
                 {SC}, {TSO}, and {PSO} Memory Models",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "1",
  pages =        "6:1--6:??",
  month =        mar,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3579835",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Thu Mar 9 07:36:32 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3579835",
  abstract =     "Automatically verifying multi-threaded programs is
                 difficult because of the vast number of thread
                 interleavings, a problem aggravated by weak memory
                 consistency. Partial orders can help with verification
                 because they can represent many thread \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Murali:2023:FOL,
  author =       "Adithya Murali and Lucas Pe{\~n}a and Christof
                 L{\"o}ding and P. Madhusudan",
  title =        "A First-order Logic with Frames",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3583057",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3583057",
  abstract =     "We propose a novel logic, Frame Logic (FL), that
                 extends first-order logic and recursive definitions
                 with a construct Sp ($ \cdot $) that captures the
                 implicit supports of formulas-the precise subset of the
                 universe upon which their meaning depends. Using such
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Toro:2023:CLT,
  author =       "Mat{\'\i}as Toro and David Darais and Chike Abuah and
                 Joseph P. Near and Dami{\'a}n {\'A}rquez and Federico
                 Olmedo and {\'E}ric Tanter",
  title =        "Contextual Linear Types for Differential Privacy",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3589207",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3589207",
  abstract =     "Language support for differentially private
                 programming is both crucial and delicate. While
                 elaborate program logics can be very expressive,
                 type-system-based approaches using linear types tend to
                 be more lightweight and amenable to automatic checking
                 and \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Jia:2023:DBP,
  author =       "Xiaodong Jia and Ashish Kumar and Gang Tan",
  title =        "A Derivative-based Parser Generator for Visibly
                 Pushdown Grammars",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "9:1--9:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3591472",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591472",
  abstract =     "In this article, we present a derivative-based,
                 functional recognizer and parser generator for visibly
                 pushdown grammars. The generated parser accepts
                 ambiguous grammars and produces a parse forest
                 containing all valid parse trees for an input string in
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "9",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Basso:2023:OAC,
  author =       "Matteo Basso and Aleksandar Prokopec and Andrea
                 Ros{\`a} and Walter Binder",
  title =        "Optimization-Aware Compiler-Level Event Profiling",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "10:1--10:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3591473",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591473",
  abstract =     "Tracking specific events in a program's execution,
                 such as object allocation or lock acquisition, is at
                 the heart of dynamic analysis. Despite the apparent
                 simplicity of this task, quantifying these events is
                 challenging due to the presence of compiler \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Yip:2023:SDP,
  author =       "Eugene Yip and Alain Girault and Partha S. Roop and
                 Morteza Biglari-Abhari",
  title =        "Synchronous Deterministic Parallel Programming for
                 Multi-Cores with {ForeC}",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "11:1--11:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3591594",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591594",
  abstract =     "Embedded real-time systems are tightly integrated with
                 their physical environment. Their correctness depends
                 both on the outputs and timeliness of their
                 computations. The increasing use of multi-core
                 processors in such systems is pushing embedded
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "11",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Sanchez-Stern:2023:PIA,
  author =       "Alex Sanchez-Stern and Emily First and Timothy Zhou
                 and Zhanna Kaufman and Yuriy Brun and Talia Ringer",
  title =        "{Passport}: Improving Automated Formal Verification
                 Using Identifiers",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "12:1--12:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3593374",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3593374",
  abstract =     "Formally verifying system properties is one of the
                 most effective ways of improving system quality, but
                 its high manual effort requirements often render it
                 prohibitively expensive. Tools that automate formal
                 verification by learning from proof corpora to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Soares:2023:SCE,
  author =       "Luigi Soares and Michael Canesche and Fernando Magno
                 Quint{\~a}o Pereira",
  title =        "Side-channel Elimination via Partial Control-flow
                 Linearization",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "2",
  pages =        "13:1--13:??",
  month =        jun,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3594736",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Tue Aug 1 10:07:18 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3594736",
  abstract =     "Partial control-flow linearization is a code
                 transformation conceived to maximize work performed in
                 vectorized programs. In this article, we find a new
                 service for it. We show that partial control-flow
                 linearization protects programs against timing
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Scott:2023:MIP,
  author =       "Elizabeth Scott and Adrian Johnstone and Robert
                 Walsh",
  title =        "Multiple Input Parsing and Lexical Analysis",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "14:1--14:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3594734",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3594734",
  abstract =     "This article introduces two new approaches in the
                 areas of lexical analysis and context-free parsing. We
                 present an extension, MGLL, of generalised parsing
                 which allows multiple input strings to be parsed
                 together efficiently, and we present an enhanced
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Haselwarter:2023:SFF,
  author =       "Philipp G. Haselwarter and Exequiel Rivas and Antoine
                 {Van Muylder} and Th{\'e}o Winterhalter and Carmine
                 Abate and Nikolaj Sidorenco and Catalin Hritcu and
                 Kenji Maillard and Bas Spitters",
  title =        "{SSProve}: a Foundational Framework for Modular
                 Cryptographic Proofs in {Coq}",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "15:1--15:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3594735",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2020.bib;
                 https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3594735",
  abstract =     "State-separating proofs (SSP) is a recent methodology
                 for structuring game-based cryptographic proofs in a
                 modular way, by using algebraic laws to exploit the
                 modular structure of composed protocols. While
                 promising, this methodology was previously not
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Lee:2023:OHE,
  author =       "Dongkwon Lee and Woosuk Lee and Hakjoo Oh and
                 Kwangkeun Yi",
  title =        "Optimizing Homomorphic Evaluation Circuits by Program
                 Synthesis and Time-bounded Exhaustive Search",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "16:1--16:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3591622",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3591622",
  abstract =     "We present a new and general method for optimizing
                 homomorphic evaluation circuits. Although fully
                 homomorphic encryption (FHE) holds the promise of
                 enabling safe and secure third party computation,
                 building FHE applications has been challenging due to
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Richter:2023:PTL,
  author =       "David Richter and David Kretzler and Pascal
                 Weisenburger and Guido Salvaneschi and Sebastian Faust
                 and Mira Mezini",
  title =        "Prisma : a Tierless Language for Enforcing
                 Contract-client Protocols in Decentralized
                 Applications",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "17:1--17:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3604629",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604629",
  abstract =     "Decentralized applications (dApps) consist of smart
                 contracts that run on blockchains and clients that
                 model collaborating parties. dApps are used to model
                 financial and legal business functionality. Today,
                 contracts and clients are written as separate
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "17",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Hietala:2023:VOQ,
  author =       "Kesha Hietala and Robert Rand and Liyi Li and Shih-Han
                 Hung and Xiaodi Wu and Michael Hicks",
  title =        "A Verified Optimizer for Quantum Circuits",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "18:1--18:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3604630",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3604630",
  abstract =     "We present voqc, the first verified optimizer for
                 quantum circuits, written using the Coq proof
                 assistant. Quantum circuits are expressed as programs
                 in a simple, low-level language called sqir, a small
                 quantum intermediate representation, which is deeply
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Chiari:2023:MCO,
  author =       "Michele Chiari and Dino Mandrioli and Francesco
                 Pontiggia and Matteo Pradella",
  title =        "A Model Checker for Operator Precedence Languages",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "3",
  pages =        "19:1--19:??",
  month =        sep,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3608443",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Fri Sep 29 08:24:08 MDT 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3608443",
  abstract =     "The problem of extending model checking from finite
                 state machines to procedural programs has fostered much
                 research toward the definition of temporal logics for
                 reasoning on context-free structures. The most notable
                 of such results are temporal logics on \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Vukasovic:2023:EPC,
  author =       "Maja Vukasovic and Aleksandar Prokopec",
  title =        "Exploiting Partially Context-sensitive Profiles to
                 Improve Performance of Hot Code",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "4",
  pages =        "20:1--20:??",
  month =        dec,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3612937",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Dec 23 05:58:17 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3612937",
  abstract =     "Availability of profiling information is a major
                 advantage of just-in-time (JIT) compilation. Profiles
                 guide the compilation order and optimizations, thus
                 substantially improving program performance.
                 Ahead-of-time (AOT) compilation can also utilize
                 \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Boruch-Gruszecki:2023:CT,
  author =       "Aleksander Boruch-Gruszecki and Martin Odersky and
                 Edward Lee and Ondrej Lhot{\'a}k and Jonathan
                 Brachth{\"a}user",
  title =        "Capturing Types",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "4",
  pages =        "21:1--21:??",
  month =        dec,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3618003",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Dec 23 05:58:17 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3618003",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "21",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}

@Article{Economou:2023:FRT,
  author =       "Dimitrios J. Economou and Neel Krishnaswami and Jana
                 Dunfield",
  title =        "Focusing on Refinement Typing",
  journal =      j-TOPLAS,
  volume =       "45",
  number =       "4",
  pages =        "22:1--22:??",
  month =        dec,
  year =         "2023",
  CODEN =        "ATPSDT",
  DOI =          "https://doi.org/10.1145/3610408",
  ISSN =         "0164-0925 (print), 1558-4593 (electronic)",
  ISSN-L =       "0164-0925",
  bibdate =      "Sat Dec 23 05:58:17 MST 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/toplas.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3610408",
  abstract =     "We present a logically principled foundation for
                 systematizing, in a way that works with any
                 computational effect and evaluation order, SMT
                 constraint generation seen in refinement type systems
                 for functional programming languages. By carefully
                 combining \ldots{}",
  acknowledgement = ack-nhfb,
  ajournal =     "ACM Trans. Program. Lang. Syst.",
  articleno =    "22",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "https://dl.acm.org/loi/toplas",
}